Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T03:46:37Z

Ubsingh:

'''Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.
'''

'''What are Design Patterns
'''

Patterns are simply ''proven solutions to common problems''. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.

It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.

A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns

• It solves a problem

• It is a proven concept

• The solution isn't obvious

• It describes a relationship

• The pattern has a significant human component

'''GRASP Patterns
'''

These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for '''G'''eneral '''R'''esponsibility '''A'''ssignment '''S'''oftware '''P'''atterns.

General => Abstract; '''widely applicable'''

Responsibility => '''Obligations''', duties

Assignment => '''Giving a responsibility to a module'''

Software => '''Computer code'''

Patterns => Regularities, templates, '''abstractions
'''

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:

Information Expert

Creator

Controller

Low Coupling

High Cohesion

Polymorphism

Pure Fabrication

Indirection

Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:

- '''Knowing responsibilities''' that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.

- '''Doing responsibilities''' include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

'''Controller Pattern
'''

The Controller pattern addresses the question: ''Who handles a system event''?

The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.

For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.

So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:

''If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.''

The events should be handled by classes representing one of the following choices:

- A class that represents the overall system, device, or subsystem (''facade controller'').

- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

'''Facade Controller'''

If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“

'''Use Case or Session Controller'''

On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.

'''Advantages of Controller Pattern'''

- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.

- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.

'''Example 1'''

Consider an example of a convenience store where a cashier can trigger three events namely

enterItem() - Used to enter the item purchased by the customer.

endSale() - Marks the end of the sale and proceeds towards payment.

makePayment() - Initiates payment by the customer.

The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem

1. It can either be the overall system indicated by POST

2. It can be the overall business indicated by STORE

3. It can be someone in the real world who is active in the task namely the cashier

4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

[[Image:pic1.jpg]]

The choice of which one to use will be influenced by other factors such as cohesion and coupling.

A good design by the controller pattern is shown as follows

[[Image:pic2.jpg]]

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

'''Example 2'''

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:

''What first object beyond the UI layer should receive the message from the UI layer?''

As per the controller pattern the solution is as follows:

Assign the responsibility to an object representing either of following:

- Represents the overall “system” – a root object

- Represents a use case scenario within which the system operation occurs.

[[Image:pic3.jpg]]

Here again there is clear separation between the UI layer and the domain layer.

'''Example 3'''

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

[[Image:pic4.jpg]]

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T03:45:45Z

Ubsingh:

File:Pic2.jpg

2007-11-19T03:45:00Z

Ubsingh:

File:Pic1.jpg

2007-11-19T03:44:38Z

Ubsingh:

File:Pic3.jpg

2007-11-19T03:44:17Z

Ubsingh:

File:Pic4.jpg

2007-11-19T03:39:55Z

Ubsingh:

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T03:23:43Z

Ubsingh:

Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.

'''What are Design Patterns
'''

Patterns are simply ''proven solutions to common problems''. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.

It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.

A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns

• It solves a problem

• It is a proven concept

• The solution isn't obvious

• It describes a relationship

• The pattern has a significant human component

'''GRASP Patterns
'''

These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for '''G'''eneral '''R'''esponsibility '''A'''ssignment '''S'''oftware '''P'''atterns.

General => Abstract; '''widely applicable'''

Responsibility => '''Obligations''', duties

Assignment => '''Giving a responsibility to a module'''

Software => '''Computer code'''

Patterns => Regularities, templates, '''abstractions
'''

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:

Information Expert

Creator

Controller

Low Coupling

High Cohesion

Polymorphism

Pure Fabrication

Indirection

Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:

- '''Knowing responsibilities''' that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.

- '''Doing responsibilities''' include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

'''Controller Pattern
'''

The Controller pattern addresses the question: ''Who handles a system event''?

The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.

For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.

So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:

''If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.''

The events should be handled by classes representing one of the following choices:

- A class that represents the overall system, device, or subsystem (''facade controller'').

- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

'''Facade Controller'''

If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“

'''Use Case or Session Controller'''

On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.

'''Advantages of Controller Pattern'''

- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.

- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.

'''Example 1'''

Consider an example of a convenience store where a cashier can trigger three events namely

enterItem() - Used to enter the item purchased by the customer.

endSale() - Marks the end of the sale and proceeds towards payment.

makePayment() - Initiates payment by the customer.

The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem

1. It can either be the overall system indicated by POST

2. It can be the overall business indicated by STORE

3. It can be someone in the real world who is active in the task namely the cashier

4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

[[Image:pic1.jpg]]

The choice of which one to use will be influenced by other factors such as cohesion and coupling.

A good design by the controller pattern is shown as follows

[[Image:pic2.jpg]]

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

'''Example 2'''

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:

''What first object beyond the UI layer should receive the message from the UI layer?''

As per the controller pattern the solution is as follows:

Assign the responsibility to an object representing either of following:

- Represents the overall “system” – a root object

- Represents a use case scenario within which the system operation occurs.

[[Image:pic3.jpg]]

Here again there is clear separation between the UI layer and the domain layer.

'''Example 3'''

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

[[Image:pic4.jpg]]

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T03:20:04Z

Ubsingh:

Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.

'''What are Design Patterns
'''

Patterns are simply ''proven solutions to common problems''. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.

It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.

A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns

• It solves a problem

• It is a proven concept

• The solution isn't obvious

• It describes a relationship

• The pattern has a significant human component

'''GRASP Patterns
'''

These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for '''G'''eneral '''R'''esponsibility '''A'''ssignment '''S'''oftware '''P'''atterns.

General => Abstract; '''widely applicable'''

Responsibility => '''Obligations''', duties

Assignment => '''Giving a responsibility to a module'''

Software => '''Computer code'''

Patterns => Regularities, templates, '''abstractions
'''

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:

Information Expert

Creator

Controller

Low Coupling

High Cohesion

Polymorphism

Pure Fabrication

Indirection

Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:

- '''Knowing responsibilities''' that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.

- '''Doing responsibilities''' include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

'''Controller Pattern
'''

The Controller pattern addresses the question: ''Who handles a system event''?

The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.

For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.

So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:

''If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.''

The events should be handled by classes representing one of the following choices:

- A class that represents the overall system, device, or subsystem (''facade controller'').

- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

'''Facade Controller'''

If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“

'''Use Case or Session Controller'''

On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.

'''Advantages of Controller Pattern'''

- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.

- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.

'''Example 1'''

Consider an example of a convenience store where a cashier can trigger three events namely

enterItem() - Used to enter the item purchased by the customer.

endSale() - Marks the end of the sale and proceeds towards payment.

makePayment() - Initiates payment by the customer.

The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem

1. It can either be the overall system indicated by POST

2. It can be the overall business indicated by STORE

3. It can be someone in the real world who is active in the task namely the cashier

4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

The choice of which one to use will be influenced by other factors such as cohesion and coupling.

A good design by the controller pattern is shown as follows

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

'''Example 2'''

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:

''What first object beyond the UI layer should receive the message from the UI layer?''

As per the controller pattern the solution is as follows:

Assign the responsibility to an object representing either of following:

- Represents the overall “system” – a root object

- Represents a use case scenario within which the system operation occurs.

Here again there is clear separation between the UI layer and the domain layer.

'''Example 3'''

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T03:12:59Z

Ubsingh:

Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.

'''What are Design Patterns
'''

Patterns are simply ''proven solutions to common problems''. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.

It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.

A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns

• It solves a problem

• It is a proven concept

• The solution isn't obvious

• It describes a relationship

• The pattern has a significant human component

'''GRASP Patterns
'''

These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for '''G'''eneral '''R'''esponsibility '''A'''ssignment '''S'''oftware '''P'''atterns.

General => Abstract; '''widely applicable'''

Responsibility => '''Obligations''', duties

Assignment => '''Giving a responsibility to a module'''

Software => '''Computer code'''

Patterns => Regularities, templates, '''abstractions
'''

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:

Information Expert

Creator

Controller

Low Coupling

High Cohesion

Polymorphism

Pure Fabrication

Indirection

Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:

- '''Knowing responsibilities''' that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.

- '''Doing responsibilities''' include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

'''Controller Pattern
'''
The Controller pattern addresses the question: ''Who handles a system event''?

The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.

For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.

So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:

''If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.''

The events should be handled by classes representing one of the following choices:

- A class that represents the overall system, device, or subsystem (''facade controller'').

- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

'''Facade Controller'''
If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“

'''Use Case or Session Controller'''

On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.

'''Advantages of Controller Pattern'''

- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.

- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.

'''Example 1'''

Consider an example of a convenience store where a cashier can trigger three events namely

enterItem() - Used to enter the item purchased by the customer.

endSale() - Marks the end of the sale and proceeds towards payment.

makePayment() - Initiates payment by the customer.

The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem

1. It can either be the overall system indicated by POST

2. It can be the overall business indicated by STORE

3. It can be someone in the real world who is active in the task namely the cashier

4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

The choice of which one to use will be influenced by other factors such as cohesion and coupling.

A good design by the controller pattern is shown as follows

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

'''Example 2'''

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:

''What first object beyond the UI layer should receive the message from the UI layer?''

As per the controller pattern the solution is as follows:

Assign the responsibility to an object representing either of following:

- Represents the overall “system” – a root object

- Represents a use case scenario within which the system operation occurs.

Here again there is clear separation between the UI layer and the domain layer.

'''Example 3'''

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T02:59:39Z

Ubsingh:

Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.

'''What are Design Patterns
'''

Patterns are simply ''proven solutions to common problems''. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.

It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.

A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns
• It solves a problem
• It is a proven concept
• The solution isn't obvious
• It describes a relationship
• The pattern has a significant human component

'''GRASP Patterns
'''

These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for '''G'''eneral '''R'''esponsibility '''A'''ssignment '''S'''oftware '''P'''atterns.

General => Abstract; widely applicable
Responsibility => Obligations, duties
Assignment => Giving a responsibility to a module
Software => Computer code
Patterns => Regularities, templates, abstractions

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:
 Information Expert
 Creator
 Controller
 Low Coupling
 High Cohesion
 Polymorphism
 Pure Fabrication
 Indirection
 Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:
- Knowing responsibilities that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.
- Doing responsibilities include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

'''Controller Pattern
'''
The Controller pattern addresses the question: Who handles a system event?
The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.
For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.
So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:
If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.

The events should be handled by classes representing one of the following choices:
- A class that represents the overall system, device, or subsystem (facade controller).
- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

'''Facade Controller'''
If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“
Use Case or Session Controller
On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.
Advantages of Controller Pattern
- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.
- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.

'''Example 1'''

Consider an example of a convenience store where a cashier can trigger three events namely
enterItem() - Used to enter the item purchased by the customer.
endSale() - Marks the end of the sale and proceeds towards payment
makePayment() - Initiates payment by the customer.
The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem
1. It can either be the overall system indicated by POST
2. It can be the overall business indicated by STORE
3. It can be someone in the real world who is active in the task namely the cashier
4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

POST

STORE
CASHIER

BuyItemsHandler
The choice of which one to use will be influenced by other factors such as cohesion and coupling.
A good design by the controller pattern is shown as follows

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

'''Example 2'''

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:
What first object beyond the UI layer should receive the message from the UI layer?

As per the controller pattern the solution is as follows:
Assign the responsibility to an object representing either of following:
- Represents the overall “system” – a root object
- Represents a use case scenario within which the system operation occurs.

Here again there is clear separation between the UI layer and the domain layer.

'''Example 3'''

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T02:56:21Z

Ubsingh:

Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.

'''What are Design Patterns
'''
Patterns are simply proven solutions to common problems. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.
It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.
A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns
• It solves a problem
• It is a proven concept
• The solution isn't obvious
• It describes a relationship
• The pattern has a significant human component

'''GRASP Patterns
'''
These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for General Responsibility Assignment Software Patterns.

General => Abstract; widely applicable
Responsibility => Obligations, duties
Assignment => Giving a responsibility to a module
Software => Computer code
Patterns => Regularities, templates, abstractions

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:
 Information Expert
 Creator
 Controller
 Low Coupling
 High Cohesion
 Polymorphism
 Pure Fabrication
 Indirection
 Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:
- Knowing responsibilities that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.
- Doing responsibilities include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

'''Controller Pattern
'''
The Controller pattern addresses the question: Who handles a system event?
The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.
For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.
So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:
If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.

The events should be handled by classes representing one of the following choices:
- A class that represents the overall system, device, or subsystem (facade controller).
- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

'''Facade Controller'''
If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“
Use Case or Session Controller
On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.
Advantages of Controller Pattern
- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.
- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.

'''Example 1'''

Consider an example of a convenience store where a cashier can trigger three events namely
enterItem() - Used to enter the item purchased by the customer.
endSale() - Marks the end of the sale and proceeds towards payment
makePayment() - Initiates payment by the customer.
The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem
1. It can either be the overall system indicated by POST
2. It can be the overall business indicated by STORE
3. It can be someone in the real world who is active in the task namely the cashier
4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

POST

STORE
CASHIER

BuyItemsHandler
The choice of which one to use will be influenced by other factors such as cohesion and coupling.
A good design by the controller pattern is shown as follows

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

'''Example 2'''

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:
What first object beyond the UI layer should receive the message from the UI layer?

As per the controller pattern the solution is as follows:
Assign the responsibility to an object representing either of following:
- Represents the overall “system” – a root object
- Represents a use case scenario within which the system operation occurs.

Here again there is clear separation between the UI layer and the domain layer.

'''Example 3'''

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

CSC/ECE 517 Fall 2007/wiki3 6 ub

2007-11-19T02:54:16Z

Ubsingh:

Take the Controller pattern (which we did not cover in class) and catalog the information on it available on the Web. Find good descriptions and good, concise, understandable examples. Tell which you consider the best to present to a class.

What are Design Patterns

Patterns are simply proven solutions to common problems. A pattern addresses a recurring design problem that arises in specific design situations and presents a solution to it. This is done by defining a set of rules which describes how to solve the problem at hand.
It is often the case that patterns are not invented but are discovered. Sometimes a pattern can be as simple as an advice from a previous designer, which helps future designers to cope with new situations.
A design pattern by no means is a panacea. It is not as easy as finding the right pattern and simply applying it to get the solution. The application of a pattern to a problem requires careful analysis to ensure that the pattern actually applies to the problem. It is important to make sure the pattern does not have negative side effects upon the rest of the system or other requirements.

Characteristics of Good patterns
• It solves a problem
• It is a proven concept
• The solution isn't obvious
• It describes a relationship
• The pattern has a significant human component

GRASP Patterns

These belong to a type known as process patterns. They describe an appropriate way of performing tasks. GRASP stands for General Responsibility Assignment Software Patterns.

General => Abstract; widely applicable
Responsibility => Obligations, duties
Assignment => Giving a responsibility to a module
Software => Computer code
Patterns => Regularities, templates, abstractions

There are several GRASP patterns, but we will only look at a few of the more important ones. Some of them are simply good design principles, and one can argue whether they are really patterns. For example, High Cohesion and Low Coupling are two that are well-known design principles and not really patterns.

The full set of GRASP patterns are:
 Information Expert
 Creator
 Controller
 Low Coupling
 High Cohesion
 Polymorphism
 Pure Fabrication
 Indirection
 Protected Variations

GRASP can be used as a methodical approach to learning basic object design. These are patterns of assigning responsibilities. There are two types of responsibilities:
- Knowing responsibilities that include knowing about private encapsulated data, about related objects, and things it can derive or calculate.
- Doing responsibilities include doing something itself, like creating another object or doing a calculation, initiating action in other objects, and controlling and coordinating activities in other objects.

Controller Pattern

The Controller pattern addresses the question: Who handles a system event?
The events under consideration here are the ones initiated from a source outside the system. Thus the system should have some class that receives the event, but that does not necessarily mean that it should handle the event.
For example security video cameras are meant to receive an event wherein there is an attempt to intrude into a house but they do not take any steps to catch the intruder. Thus they are mere receivers and the event handling is done by some other part of the security system.
So the controller pattern can be used when we are faced with the problem of assigning responsibility of handling a system event. The solution to this problem as proposed by the controller patterns is as follows:
If a program receives events from external sources other than its graphical interface, add an event class to decouple the event source(s) from the objects that actually handle the events.

The events should be handled by classes representing one of the following choices:
- A class that represents the overall system, device, or subsystem (facade controller).
- A class that represents a use case scenario within which the system event occurs. These are often named <usecasename>Handler, <usecasename>Controller,
<usecasename> Manager, and so forth.

Whether to use façade controller or use case controller?

Facade Controller
If we do not have a lot of messages that need to be handled by the controller, we can use a single object that represents the overall system. For example, if we are building an application that manages our contacts, addresses, and phone numbers, you could call this object “AddressBook.” If we are building an e-commerce website, we could call this object “Store.” If we are building a chess game, we could call this object “ChessGame.“
Use Case or Session Controller
On the other hand, if we have a lot of messages that needed to be handled by the controller, we risk the chance of losing cohesiveness if we use a single facade controller. In this case, we should define a single controller for all the system events associated with a single use case. So, in our e-commerce website example above, we may have several use case controllers, called “HandleReturn”, “ProcessSale”, “ProcessPayment”, “ManageAccount”, etc. Thus for most applications, the use case or session controller tends to be used.
Advantages of Controller Pattern
- There is increased potential for reuse. Using a controller object keeps external event sources and internal event handlers independent of each other’s type and behaviour.
- It provides more information about the states of the use case. It also enables us to ensure that the system operations occur in a legal sequence by providing more information about the current state of activity and operations within the use case.
Example 1
Consider an example of a convenience store where a cashier can trigger three events namely
enterItem() - Used to enter the item purchased by the customer.
endSale() - Marks the end of the sale and proceeds towards payment
makePayment() - Initiates payment by the customer.
The problem can be stated as: Who has the responsibility for the enterItem() event?
By the controller pattern we have four solutions to our problem
1. It can either be the overall system indicated by POST
2. It can be the overall business indicated by STORE
3. It can be someone in the real world who is active in the task namely the cashier
4. It can be an artificial handler of all system events of a use case denoted by BuyItemsHandler().

POST

STORE
CASHIER

BuyItemsHandler
The choice of which one to use will be influenced by other factors such as cohesion and coupling.
A good design by the controller pattern is shown as follows

It is important to note how the presentation layer is decoupled from the domain layer.
Assigning the responsibility for system operations to objects in the domain layer rather than presentation layer supports increased reuse potential. It also makes it easier to unplug the interface layer and use a different interface technology, or to run the system in an off-line “batch” mode.

Example 2

A game of monopoly is a good example of a controller pattern in which the actors are the players who generate events like clicking a button with a mouse to play a game or make a move. The UI software objects (such as a JFrame window and a JButton) must process the event and cause the game to play. When objects in the UI layer pick up an event, they must delegate the request to an object in the domain layer.

The problem in this case can be formulated as follows:
What first object beyond the UI layer should receive the message from the UI layer?

As per the controller pattern the solution is as follows:
Assign the responsibility to an object representing either of following:
- Represents the overall “system” – a root object
- Represents a use case scenario within which the system operation occurs.

Here again there is clear separation between the UI layer and the domain layer.

Example 3

In an example of Jukebox program, responsibility is assigned to a controller class to handle events from external actors, e.g. startup(), playSongs(), etc. The controller class represents the overall system, device, or subsystem, which often don’t do the work, but delegate it to processing layer. Processing layer is responsible for actually doing work by calling methods such as deviceInitialize() and executePlaySongs().

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-29T19:06:45Z

Ubsingh:

'''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
'''

A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.

A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.

'''Example of Class in C++

#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}'''

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.

'''Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}'''

'''Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>'''

'''Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}'''

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.

'''Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end'''

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

'''Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}'''

'''Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}'''

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

'''Additional Resources'''

''Java Related resources''

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.neiu.edu/~ncaftori/java/class06.html

http://www.javalobby.org/java/forums/t18560.html

''Other Programming Languages''

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

http://rubylearning.com/satishtalim/writing_our_own_class_in_ruby.html

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-29T19:03:07Z

Ubsingh:

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-29T18:56:20Z

Ubsingh:

'''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
'''

A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.

A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.

'''Example of Class in C++

#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}'''

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.

'''Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}'''

'''Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>'''

'''Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}'''

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.

'''Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end'''

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

'''Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}'''

'''Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}'''

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

'''More Resources'''

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-24T00:46:26Z

Ubsingh:

'''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
'''

A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.

A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.

'''Example of Class in C++

#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}'''

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.

'''Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}'''

'''Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>'''

'''Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}'''

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.

'''Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end'''

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

'''Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}'''

'''Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}'''

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

Some resources to learn more about class and type are –

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-23T15:21:08Z

Ubsingh:

'''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
'''

A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.
A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.

'''Example of Class in C++

#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}'''

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.

'''Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}'''

'''Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>'''

'''Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}'''

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.

'''Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end'''

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

'''Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}'''

'''Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}'''

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

Some more resources to learn more about class and type are –

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-23T15:16:52Z

Ubsingh:

'''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
'''

A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.
A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.

'''Example of Class in C++
#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}'''

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.

'''Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}'''

'''Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>'''

'''Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}'''

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.

'''Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end'''

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

'''Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}'''

'''Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}'''

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

Some more resources to learn more about class and type are –

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-23T15:14:51Z

Ubsingh:

'''Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
'''

A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.
A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.
Example of Class in C++
#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.
////////////////////////////////////////////////////////////////////////////////
Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>

/////////////////////////////////////////////////////////////////////////////////////////////////
Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.
////////////////////////////////////////////////////////////////////////////////////////////////
Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}

Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

Some more resources to learn more about class and type are –

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

CSC/ECE 517 Fall 2007/wiki2 6 ubs

2007-10-23T15:14:18Z

Ubsingh:

Type vs. class. Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects.
A class is a cohesive package that consists of a particular kind of metadata. It describes the rules by which objects behave; these objects are referred to as instances of that class. A class specifies the structure of data (a.k.a. properties, fields, attributes, data members) within each instance as well as methods (functions) (a.k.a. behaviors) which manipulate the data of the object and perform tasks. A class is the most specific type of an object in relation to a specific layer. A class may also have a representation (metaobject) at runtime, which provides runtime support for manipulating the class-related metadata. The term class is traditionally used to imply an object created by the class statement. Once a class is defined, it can be treated as a new kind of data type.
A type is a set of data values, and a set of operations (methods) on those values, applied to an object. Yet another definition of type is – type is the definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.
Type defines the proper use of a name or an expression. Type can be a built-in-type or a user-defined type. In programming language like C++, type provided directly by the language such as int, double, and char* is called built-in-type. Class or Enumeration is used to define user-defined type. In Java language, types can be defined using classes and interfaces. So by creating a new class, a new type is created. But that is not true with all programming languages. For instance, in Python all classes are of type ClassType, and all class interfaces are of type InstanceType.
Example of Class in C++
#include <iostream>
#include <string>

class Hello
{
std::string what;

public:
Hello(const char* s)
: what(s)
{
}

void say()
{
std::cout << "Hello " << what << "!" << std::endl;
}
};

int main( int argc, char** argv )
{
Hello hello_world("world");
hello_world.say();

return 0;
}

This example shows how to define a C++ class named "Hello". It has a private string attribute named "what", and a public method named "say". In this example, user-defined type is created by declaring class “Hello”. Instance of class Hello “Hello_world” belongs to user-defined type. Also, in line :std::string what;”, variable what belongs to a built-in type ‘string’.
////////////////////////////////////////////////////////////////////////////////
Example of Class in Java
public class Example1
{
// This is a Java class, it automatically extends the class Object
public static void main (String args[])
{
System.out.println("Hello world!");
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
Example of Class in PHP
<?php
class A {
public function foo() {
echo “Hello World”
}
}
?>

/////////////////////////////////////////////////////////////////////////////////////////////////
Examples in C#
using System;

public class Program
{
public static void Main(string[] args)
{
System.Console.WriteLine("Hello world!");
}
}

This example demonstrates a traditional "Hello world!" example in Microsoft's C# language. The Program class contains a single static method, Main(), which calls System.Console.WriteLine to print text onto the console.
////////////////////////////////////////////////////////////////////////////////////////////////
Example in Ruby

class Person
@@count = 0
def initialize(name, height)
@name = name
@height = height
@@count += 1
end
def self.info
puts "Number of instances = #{@@count}"
end
def to_s
"Name: #{@name} Height: #{@height}"
end
end

This defines a Person class with attributes name and height. It has a class variable count, which keeps track of the number of instances of the class created.

Examples of Type in Java

public class Color
{
String Red, Blue, Green;
}
public class Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived extends IBase
{
void G();
}
public class A
{
protected void H() {
System.out.println("A.H");
}
}
public class B extends A implements IDerived
{
public void F() {
System.out.println("B.F, implementation of IDerived.F");
}
public void G() {
System.out.println("B.G, implementation of IDerived.G");
}
protected void H() {
System.out.println("B.H, override of A.H");
}
}

Examples of Type in C#

public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}

Above examples clearly demonstrate usage of type. Red, blue and green have type of ‘Color’. X, Y are ‘Point’ type.

Here is another excerpt that distinguish class and type.
“Classes were created with 'class', and they were fundamentally different from C types created in extension modules. All instances of old-style classes are of type 'instance', which is why they have the __class__ attribute, so you can find their actual class. (Functions like "isinstance" contain hacks to support old-style classes.) New-style classes elevate Python-level classes to types equal to the built-in ones, which is why the word "type" is now
sufficient for both.”

Some more resources to learn more about class and type are –

http://java.sun.com/docs/books/tutorial/java/concepts/class.html

http://www.cplusplus.com/doc/tutorial/classes.html

http://www.ibiblio.org/g2swap/byteofpython/read/oops.html

http://msdn2.microsoft.com/en-us/vbasic/ms789107.aspx

CSC/ECE 517 Fall 2007/wiki1b 2 c9

2007-10-10T01:44:09Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
'''Wiki Assignment'''

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
'''class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end'''
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

'''class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end'''

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

'''def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end'''

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)

'''def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end'''

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)

'''class LolCat
def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end
end'''

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki1b 2 c9

2007-10-10T01:43:36Z

Ubsingh:

CSC/ECE 517 Fall 2007/wiki1b 2 c9

2007-10-10T01:40:55Z

Ubsingh:

CSC/ECE 517 Fall 2007/wiki1b 2 c9

2007-10-10T01:39:12Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
'''Wiki Assignment'''

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
'''class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end'''
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

'''class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end'''

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

'''def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end'''

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)

'''def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end
'''

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)

'''class LolCat
def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end
end
'''

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki1b 2 c9

2007-10-10T01:36:41Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
'''Wiki Assignment'''

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
'''class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end'''
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

'''class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end'''

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

'''def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end'''

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
'''def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end'''

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
'''class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end'''

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki1b 2 c9

2007-10-01T13:53:43Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
'''Wiki Assignment'''

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki1 2 c9

2007-10-01T13:53:17Z

Ubsingh:

CSC/ECE 517 Fall 2007/wiki2 c9

2007-10-01T13:51:10Z

Ubsingh:

CSC/ECE 517 Fall 2007/wiki1 2 c9

2007-10-01T13:50:39Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
'''Wiki Assignment'''

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki2 c9

2007-09-30T16:21:18Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
'''Wiki Assignment'''

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki2 c9

2007-09-30T16:20:11Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
Wiki Assignment

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Source: http://rubylearning.com/satishtalim/ruby_method_missing.html
class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here, please try again."
end
end
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here, please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

In the following example, method method_missing intercepts and prints out a message with method name and argument list (if any) and forwards on the method call using 'send' method without knowing anything about the object passed to it. (source: http://blog.mauricecodik.com/2005/12/more-ruby-methodmissing.html)

class SimpleCallLogger
def initialize(o)
@obj = o
end
def method_missing(methodname, *args)
puts "called: #{methodname}(#{args})"
a = @obj.send(methodname, *args)
puts "\t-> returned: #{a}"
return a
end
end

Another use of method_missing: (Source: http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their web page changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Source: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (source: http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordingly.

CSC/ECE 517 Fall 2007/wiki2 c9

2007-09-30T16:00:10Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
Wiki Assignment

'''Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.'''

Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Link used http://rubylearning.com/satishtalim/ruby_method_missing.html
class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here please try again."
end
end
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here -please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

Another use of method_missing: (Link http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their webpage changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Link: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (Link http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordindly.

CSC/ECE 517 Fall 2007/wiki2 c9

2007-09-30T15:57:59Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems
Wiki Assignment

Topic 2 : There are plenty of examples of method_missing on the Web. Unfortunately, I find most of them rather difficult to understand. One needs to look at quite a bit of source code and figure out what it does. Fix this by giving a plain-English description of several uses of method_missing not covered in our class, with Web links to the pages where you found them.
Ruby has a powerful way to intercept calls to undefined method. This is implemented by defining method_missing in our class definition. If a call is made to an undefined method on a object, Ruby passes the name of the method and its arguments to the method_missing. This is an efficient and safest way to intercept calls made to unknown methods and handles them in a proper fashion.
Let us look into few examples (Link used http://rubylearning.com/satishtalim/ruby_method_missing.html
class Dummy
def method_missing(m, *args)
puts "There's no method called #{m} here please try again."
end
end
Dummy.new.anything
>ruby tmp.rb
Output: There's no method called anything here -please try again.
In the above example, a call is made to a method called anything on object of class Dummy. There is no method called “anything” defined within the class. Ruby passes the name “anything” to method_missing. Hence the above output is displayed.

Another use of method_missing: (Link http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html)

def method_missing(method)
@posts = User.find_first(['username = ?', method.to_s]).posts
render_action 'index'
cache_page if ActionController::Base.perform_caching
end

The above code is an example of a controller used for generating RSS and Atom Feeds to user. It is used by Elite Journal which is a multi user. Since their webpage changes display every now and then depending upon the status of user login. Therefore caching the output is very hard. Therefore, most of the time the output is not cached. So, generally the RSS and Atom Feeds are cached. Since Elite Journal is multi-user, there is a feed for each user. This feed is combined with the method_missing call such that a call to the /rss/scott URL will retrieve the feed to the user “Scott”. In the above example, the page is cached if caching is enabled by the action controller.
Another set of example for the use of method_missing is as follows: (Link: facets.rubyforge.org/src/lib/facets/core/kernel/as.rb)
def method_missing(sym, *args, &blk)
@ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
end
require 'rubygems'
require 'facets'

module James
def name
"James"
end
end

module Lynn
def name
"Lynn"
end
end

class FamilyMember
include James
include Lynn
end

FamilyMember.ancestors # => [FamilyMember, Lynn, James, Object, Kernel]
member = FamilyMember.new
member.name # => "Lynn"
member.as(James).name # => "James"

In above example method_missing definition allows you to call a method on any ancestor. Initially instance of FamilyMember i.e member receives a message as which returns an instance of As. After returning the instance of As, member receives messae “name”. Since As does not contain the definition of name, the method_missing is called where in name is passed as an arguments. Within the method, instance_method is called on the ancestor with the name as the symbol. The instance_method will return the unbound method name since it is not defined. Then, method_missing binds the name to the subject which is member (instance of FamilyMember) and sends a call message along with the arguments passed before. Here, since name binds to the member, it can access the state or behavior of the member.
Last example for the purpose of using method_missing. (Link http://services.tucows.com/developers/2007/08/03/rubys-method_missing-method-explained-with-lolcats/)
class LolCat

def confess
puts “I made you a cookie…but then I eated it.”
end

def eat
puts “NOM NOM NOM.”
end

def method_missing(method)
puts “Oh noes! I has no idea how to #{method}.”
end

end

> kitty = LolCat.new
=> #<LolCat:0x349a40>

> kitty.confess
I made you a cookie...but then I eated it.
=> nil

> kitty.eat
NOM NOM NOM.
=> nil

> kitty.poop
Oh noes! I has no idea how to poop.
=> nil

In the above example, we create an instance of LolCat which is named kitty. Next, call the method “confess” on kitty. Since it is defined , the method “confess” is called and appropriate result is printed. When the method poop is called, the method_missing is called since the method “poop” is not defined. Ruby passes the name of the method i.e “confess” and arguments that are needed to the method “poop”. The method_missing displays an error accordindly.

CSC/ECE 517 Fall 2007wiki2 c9

2007-09-25T14:54:46Z

Ubsingh:

CSC/ECE 517 Fall 2007

2007-09-25T14:52:47Z

Ubsingh:

CSC- 517 Object-Oriented Languages and Systems

CSC/ECE 517 Fall 2007

2007-09-25T14:50:51Z

Ubsingh: