Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-27T08:06:30Z

Asheikh: /* Objectives */

'''V - Model'''

=='''Introduction'''==
[[File:Wiki image.jpg|thumb|420px|The V-model of the Systems Engineering Process.]]
The V-model also called as Verification and Validation model is a [http://en.wikipedia.org/wiki/Software_development_process software development process] which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the [http://en.wikipedia.org/wiki/Waterfall_model waterfall model]. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the [http://en.wikipedia.org/wiki/Software_testing_life_cycle testing cycle].

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the [http://www.investopedia.com/terms/d/developmentstage.asp#axzz2AS3WFJBq stages of development] with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the [http://en.wikipedia.org/wiki/Planning planning] and [http://en.wikipedia.org/wiki/Implementation realization] of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined intermediate results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all [http://en.wikipedia.org/wiki/Stakeholder Stakeholders]: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==
[[File:V model001.jpg|thumb|420px|V-Model in detail.]]

Verification ensures that, the software is being built correctly. The [http://en.wikipedia.org/wiki/International_Software_Testing_Qualifications_Board ISTQB] defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

===Requirements Analysis===

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

===System Design===

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

===Architecture Design===

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

===Module Design===

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the life-cycle. The explicit recognition of testing in the V-model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

=='''References'''==

*http://www.softwaretestingclass.com/v-model/

*http://en.wikipedia.org/wiki/V-Model_(software_development)

*http://en.wikipedia.org/wiki/V-Model

*http://www.careerride.com/testing-v-model.aspx

*http://www.softwaretestingmentor.com/sdlc/vmodel.php

*http://www.bucanac.com/documents/The_V-Model.pdf

*http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-27T08:05:48Z

Asheikh: /* Objectives */

'''V - Model'''

=='''Introduction'''==
[[File:Wiki image.jpg|thumb|420px|The V-model of the Systems Engineering Process.]]
The V-model also called as Verification and Validation model is a [http://en.wikipedia.org/wiki/Software_development_process software development process] which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the [http://en.wikipedia.org/wiki/Waterfall_model waterfall model]. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the [http://en.wikipedia.org/wiki/Software_testing_life_cycle testing cycle].

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the [http://www.investopedia.com/terms/d/developmentstage.asp#axzz2AS3WFJBq stages of development] with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the [http://en.wikipedia.org/wiki/Planning planning] and [http://en.wikipedia.org/wiki/Implementation realization] of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all [http://en.wikipedia.org/wiki/Stakeholder Stakeholders]: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==
[[File:V model001.jpg|thumb|420px|V-Model in detail.]]

Verification ensures that, the software is being built correctly. The [http://en.wikipedia.org/wiki/International_Software_Testing_Qualifications_Board ISTQB] defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

===Requirements Analysis===

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

===System Design===

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

===Architecture Design===

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

===Module Design===

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the life-cycle. The explicit recognition of testing in the V-model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

=='''References'''==

*http://www.softwaretestingclass.com/v-model/

*http://en.wikipedia.org/wiki/V-Model_(software_development)

*http://en.wikipedia.org/wiki/V-Model

*http://www.careerride.com/testing-v-model.aspx

*http://www.softwaretestingmentor.com/sdlc/vmodel.php

*http://www.bucanac.com/documents/The_V-Model.pdf

*http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:57:38Z

Asheikh: /* References */

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

===Requirements Analysis===

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

===System Design===

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

===Architecture Design===

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

===Module Design===

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

*http://www.softwaretestingclass.com/v-model/

*http://en.wikipedia.org/wiki/V-Model_(software_development)

*http://en.wikipedia.org/wiki/V-Model

*http://www.careerride.com/testing-v-model.aspx

*http://www.softwaretestingmentor.com/sdlc/vmodel.php

*http://www.bucanac.com/documents/The_V-Model.pdf

*http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:16:16Z

Asheikh: /* References */

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

===Requirements Analysis===

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

===System Design===

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

===Architecture Design===

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

===Module Design===

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:15:20Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

===Requirements Analysis===

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

===System Design===

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

===Architecture Design===

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

===Module Design===

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:14:15Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

==='''Verification phase'''===

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

===Requirements Analysis===

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

===System Design===

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

===Architecture Design===

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

===Module Design===

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:12:39Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

==='Verification phase'''===

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

==Requirements Analysis==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

==System Design==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

==Architecture Design==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

==Module Design==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:11:13Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:10:37Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:10:10Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

=='''Advantages'''==

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

=='''Disadvantages'''==

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

=='''Conclusion'''==

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:09:06Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

===Advantages===

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

===Disadvantages===

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

===Conclusion===

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:08:12Z

Asheikh:

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

===Advantages===

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

===Disadvantages===

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

===Conclusion===

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:07:10Z

Asheikh: /* Objectives */

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

===Advantages===

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

===Disadvantages===

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

===Conclusion===

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:06:00Z

Asheikh: /* Further Suggested Reading */

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

�
=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

===Advantages===

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

===Disadvantages===

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

===Conclusion===

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

=='''Further Suggested Reading'''==

*Dual Vee Model - http://en.wikipedia.org/wiki/Dual_Vee_Model

*System Development Lifecycle - http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

*Product Lifecycle Management - http://en.wikipedia.org/wiki/Product_lifecycle_management

*Portal: Software Testing - http://en.wikipedia.org/wiki/Portal:Software_Testing

*IBM RUP - http://en.wikipedia.org/wiki/RUP

*Systems Architecture - http://en.wikipedia.org/wiki/Systems_architecture

*System Analysis - http://en.wikipedia.org/wiki/Systems_analysis

*System Design - http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:02:18Z

Asheikh: /* References */

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

�
=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

===Advantages===

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

===Disadvantages===

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

===Conclusion===

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/

http://en.wikipedia.org/wiki/V-Model_(software_development)

http://en.wikipedia.org/wiki/V-Model

http://www.careerride.com/testing-v-model.aspx

http://www.softwaretestingmentor.com/sdlc/vmodel.php

http://www.bucanac.com/documents/The_V-Model.pdf

http://www.compensationanalytics.com/_resources/vtestingmodel.pdf

http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

===Further Suggested Reading===

Dual Vee Model

http://en.wikipedia.org/wiki/Dual_Vee_Model

System Development Lifecycle

http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

Product Lifecycle Management

http://en.wikipedia.org/wiki/Product_lifecycle_management

Portal: Software Testing

http://en.wikipedia.org/wiki/Portal:Software_Testing

IBM RUP

http://en.wikipedia.org/wiki/RUP

Systems Architecture

http://en.wikipedia.org/wiki/Systems_architecture

System Analysis

http://en.wikipedia.org/wiki/Systems_analysis

System Design

http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch2a 2w4 sa

2012-10-25T11:01:57Z

Asheikh: /* References */

'''V - Model'''

=='''Introduction'''==

The V-model also called as Verification and Validation model is a software development process which simplifies the understanding of the complexity associated with the development of a system, and is an extension to the waterfall model. Rather than proceeding linearly downwards, after the coding phase, the process steps are bent upwards to form a V shape. This creates an association between the phases in the development and the testing cycle.

In the diagram, the left arm corresponds to the development phases in the traditional waterfall model and the right to the test phases. Each development activity carried out by the development team has its corresponding validation activity done by the testing team.

=='''From Waterfall to V-Model'''==

Every phase or stage in the waterfall model needs to be completed and signed off before the next phase can start, this rigidity affects the flexibility in iterating back and forth between the stages of development with the result being a poor quality system. The V-Model prevents this by explicitly connecting the development and testing stages.

=='''Objectives'''==

The V-Model facilitates the planning and realization of projects. The following are the objectives to be achieved during system development:

*Minimizing Project Risks: Early recognition of planning deviations and risks improves process management, thus reducing risks.

*Improving Quality: Defined interim results can be checked at an early stage. Uniform product contents will improve readability, understandability and verifiability.

*Reduction of Total Cost: The results obtained should be uniform and easily retraced. This reduces the dependency on the supplier and the effort for subsequent activities.

*Effective Communication between all Stakeholders: The miscommunication between user, supplier and developer is reduced.

�
=='''Verification phase'''==

Verification ensures that, the software is being built correctly. The ISTQB defines Verification as: “Confirmation by examination and through provision of objective evidence that specified requirements have been fulfilled.“

The first part of the definition is the same as for Validation, but the second part is the key. This states that “specified requirements have been fulfilled“. The V-model diagram arrows shows that each produced product is checked against the products or documents that were used to drive the development. This ensures that all aspects have been met. A key problem is ensuring that the user requirements are adequately verified against the customer needs. The Business Case is only likely to contain high level functionality, and not the detail about processes that are essential for determining what is required.

=='''Requirements Analysis'''==

Requirements analysis encompasses those tasks that determine the conditions specified by the stakeholders for the product. Its activities are concerned with eliciting, analyzing, documenting, validating and managing system requirements. The requirements have to be documentable, actionable, measurable, testable, traceable, related to the business needs and should include details sufficient for system design.

Requirements analysis includes three types of activities:

*Eliciting requirements: Identifying the various types of requirements from various sources i.e. project and business process documentation along with stakeholder interviews.

*Analyzing requirements: Determining whether the specified requirements are clear, complete and consistent.

*Recording requirements: Requirements can be documented in normal language documents, use cases, user stories, or system specifications.

Requirements analysis is a long process during which many changes can occur over that time period. Technology changes, business requirements changes with many other things, so it is important that the stakeholders are in constant touch with the developers to ensure that they understand the new improved system. It is the responsibility of the analyst to gather information from the customer. System prototypes should be developed to demonstrate a working model to the stakeholders. Analysts employ a combination of various methods to establish the exact requirements of the stakeholders, so that the system developed meets the customer’s needs. The information regarding the product requirements can be classified as: Customer, Architectural, Structural, Behavioral, Functional, Non-functional, Performance, Design, Derived, and Allocated Requirements.

=='''System Design'''==

This design process defines the architecture, components, modules, interfaces, and data required by a system to meet the mentioned system requirements. We can say that design is an act of taking the marketing information and creating the products to be manufactured. So, systems design is the process of defining and developing systems specified by the user.

*Softwares that run on generic platforms have enhanced software engineering.

*Object-oriented analysis and design methods are widely used for systems design.

*UML is used for modeling software systems and designing high non-software systems and organizations.

=='''Architecture Design'''==

The design of computer and software architecture can be referred to as high-level design. The architecture selected should realize the list of modules, brief functionality of each module, the interface relationships between the modules, dependencies, database tables, architecture diagrams, technology details etc.

Integration testing design is carried out in this phase.

=='''Module Design'''==

The module design phase is a low-level design. The designed system is broken up into smaller units and each of them is explained to the programmer. The low level design document will contain a detailed functional logic of the module:

*database tables, with all elements, including their type and size

*all interface details with complete API references

*all dependency issues

*error message listings

*complete input and outputs for a module.

Unit test design is developed in this stage.

=='''Coding'''==

=='''Validation phase'''==
===Importance of Early Testing===

Studies show that catching a fault early in the development stages before the system is released is more cost effective and it takes less resources to fix the system when compared to fixing it after its release. We must also take into account the reputation of the organisation, the cost associated with missing functionality, so in fact the true cost for fixing the system is much higher.

In the waterfall model errors were found very late in the cycle because testing began at the end of the project. In the V-Model testing begins as early as possible. Prior to testing, the testing team works on various activities in parallel to the development activity which helps to get the test deliverable on time which includes creation of test cases, preparation of test strategies, test planning and test scripting.

===Testing Types Matched to Development Stages===

The first noticeable point of the V-Model is that the Test stage of the Waterfall model is bent upwards to make it a “V”. This stage is now separated out into the various types of testing. So this first step visually points out that there is more than one type of testing to consider for system development and like the development steps they build on one another, and have different objectives. The next important part of the “V” is to match each type of testing against the development stage it matches e.g. we have Component Design matched against Component Testing. This means that the testing stage does not start when the Construct Component stage has ended. Instead when each development stage starts, the testing for that stage also starts.

===Unit testing===

Unit testing, tests the low level design i.e. units. A unit is a basic module of the application on which testing is carried out, it may be an individual function or a procedure. These tests are created by the developers (white box testing) to verify the internal logic code. Input data are passed to the unit to test every case of execution.

===Integration testing===

Integration testing tests high level design i.e. components and their interfaces. In Integration testing the basic units will be tested together to check the interaction between them and finds errors in the interfaces. This is generally a black box testing method. Integration testing is performed by program team leaders.

===System testing===

Once the entire system has been developed, it then has to be tested against the system specifications to validate if it provides the required features. In short, system testing is about checking the system as a whole. System testing involves a number of special types of tests to see if all the functional and nonfunctional requirements have been met. System testing is performed by system testers.
Reasons for carrying out a system test even after the unit and integration test

*The previous testings were done against the system specifications. The system test, looks at the system from the perspective of the future user.

*Many of the system functions and characteristics results from the interaction of the modules, and can be tested only at this level.

*Also, keeping in mind that the customer and the end user can be two different groups of people having their own requirements and interests.

===Acceptance testing===

The major purpose of Acceptance Testing is to validate or confirm that the system meets the business requirements and gives an assurance before it is delivered to the end user. This phase is for testing the software in the real world by the end user to determine whether to accept the system or not.

===Release testing===

This testing phase answers important questions such as

*Is the software suitable for the end user?

*Has the compatibility with other systems been ensured?

*Is the performance of the software optimized?

===Advantages===

*Early acceptance criteria is the key advantage, they are performed against a specification of requirements.

*60 to 70 percent of all faults are in the system before the component construction and test stages start, which is taken care of.

*At an early stage we can feed back to catch a fault before it is built into the system.

*Specifies test requirements and expected results prior to performing the actual tests.

*Defines who is responsible for performing the testing and provides a focus for defining the testing that takes place at each stage.

===Disadvantages===

*Too simple to reflect the development process.

*Leads project managers to a false sense of security.

*Inflexible and no ability to respond to change.

*Produces inefficient testing methodologies

*The placing of contracts for services is not regulated.

*The organization and execution of operation, maintenance, repair and disposal of the system are not covered by the V-Model.

*The V-Model addresses software development within a project rather than a whole organization.

===Conclusion===

Testing in the development process is critical. The earlier a fault is found, the cheaper it is to fix. The V model extends testing to the beginning of the lifecycle. The explicit recognition of testing in the V model makes it very useful in planning and executing information system development. The V-Model has evolved over time and supports flexibility and agility throughout the development process. Static testing techniques, such as inspections and walkthroughs, can be used to find faults in the functional specification, as well as defining test cases that are subsequently executed in system testing.

==References==

http://www.softwaretestingclass.com/v-model/
http://en.wikipedia.org/wiki/V-Model_(software_development)
http://en.wikipedia.org/wiki/V-Model
http://www.careerride.com/testing-v-model.aspx
http://www.softwaretestingmentor.com/sdlc/vmodel.php
http://www.bucanac.com/documents/The_V-Model.pdf
http://www.compensationanalytics.com/_resources/vtestingmodel.pdf
http://www.google.co.in/search?q=v+model&hl=en&biw=1241&bih=606&prmd=imvnsb&tbm=isch&tbo=u&source=univ&sa=X&ei=XVd8UICgNYem9gSa4oCYDA&sqi=2&ved=0CC8QsAQ

===Further Suggested Reading===

Dual Vee Model

http://en.wikipedia.org/wiki/Dual_Vee_Model

System Development Lifecycle

http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle

Product Lifecycle Management

http://en.wikipedia.org/wiki/Product_lifecycle_management

Portal: Software Testing

http://en.wikipedia.org/wiki/Portal:Software_Testing

IBM RUP

http://en.wikipedia.org/wiki/RUP

Systems Architecture

http://en.wikipedia.org/wiki/Systems_architecture

System Analysis

http://en.wikipedia.org/wiki/Systems_analysis

System Design

http://en.wikipedia.org/wiki/Systems_design

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-20T00:49:13Z

Asheikh: /* method_missing Implementationhttp://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/ */

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method that belongs to a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up the [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but are still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for Defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby Method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling Defined and Undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed.

Sometimes when a class has many methods that do generally the same kinds of functionality, and the programmer is not sure in advance which methods the user will call since there are so many of them, and all of them are similar, writing code for all of the methods seems futile. In these situations method_missing can be defined to take care of these cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf(Diagram)

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-20T00:44:47Z

Asheikh: /* Introductionhttp://rubylearning.com/satishtalim/ruby_method_missing.html */

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method that belongs to a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up the [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but are still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for Defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby Method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling Defined and Undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf(Diagram)

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:49:24Z

Asheikh: /* Further Suggested Reading */

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for Defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby Method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling Defined and Undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf(Diagram)

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:49:11Z

Asheikh: /* Further Suggested Reading */

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:47:51Z

Asheikh: /* Calling defined and undefined Methods */

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:47:19Z

Asheikh: /* Format for defining method_missing */

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for Defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby Method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:46:47Z

Asheikh:

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby Method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:46:27Z

Asheikh: /* Ruby method Lookup Flow */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby Method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:45:51Z

Asheikh: /* method_missing to log method callshttp://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22 */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to Log Method Calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:45:26Z

Asheikh: /* Converting Numbers from Roman Representation to Integer representationhttp://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer Representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:44:08Z

Asheikh: /* Calling defined and undefined methods */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined Methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:43:49Z

Asheikh: /* Ruby method lookup flow */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method Lookup Flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:43:22Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===Converting Numbers from Roman Representation to Integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:42:58Z

Asheikh: /* passing parameters to an undefined method call */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===Passing Parameters to an Undefined Method Call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:42:21Z

Asheikh: /* method_missing implementationhttp://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/ */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing Implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:41:12Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:40:38Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.
When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:39:51Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the example below, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:39:23Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==

*In the below example, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:38:33Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*In the below example, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*In the following example, if within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:37:26Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*In the below example, class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:32:03Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:31:09Z

Asheikh: /* dfs */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Ruby method lookup flow'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:30:14Z

Asheikh: /* Different types of methods */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''dfs'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-19T23:24:44Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exists, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-15T02:51:38Z

Asheikh: /* Disadvantages of method_missing */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

In cases where the user wants to handle the methods which are not defined but still called, “method_missing” can be defined and the user can handle the methods as he/she sees fit.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
When the object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, writing code for all of them seems futile. In these situations method_missing can be defined to take care of different cases. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The result is a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-14T12:27:07Z

Asheikh: /* Further Suggested Reading */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The result was a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*https://www.youtube.com/watch?v=SAEiCkixrdE&feature=relmfu
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-14T04:22:42Z

Asheikh: /* Key Points */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The result was a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-13T17:00:38Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.xxix
r.xxiv
r.xxvi

The Output

=> 7
=> 29
=> 24

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The expected result would be a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-13T08:39:29Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://www.rubyquiz.com/quiz22.html */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://courses.ncsu.edu/csc517/common/lectures/notes/wk2.pdf</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.iClx
r.xxix
r.xxxi
r.xxiv
r.xxvi
r.vx

The Output

Numeric Value for vii is: 7
Roman string is invalid
Numeric Value for xxix is: 29
Numeric Value for xxxi is: 31
Numeric Value for xxiv is: 24
Numeric Value for xxvi is: 26
Roman string is invalid

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The expected result would be a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-13T08:38:18Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://www.rubyquiz.com/quiz22.html */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://www.rubyquiz.com/quiz22.html</ref>===
class Roman
DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}
def roman_to_integer(roman_string)
last = nil
roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.iClx
r.xxix
r.xxxi
r.xxiv
r.xxvi
r.vx

The Output

Numeric Value for vii is: 7
Roman string is invalid
Numeric Value for xxix is: 29
Numeric Value for xxxi is: 31
Numeric Value for xxiv is: 24
Numeric Value for xxvi is: 26
Roman string is invalid

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The expected result would be a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-13T08:37:43Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://www.rubyquiz.com/quiz22.html */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Different types of methods'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://www.rubyquiz.com/quiz22.html</ref>===
class Roman

DIGITS = {'I'=>1,'V'=>5,'X'=>10,'L'=>50,'C'=>100,'D'=>500,'M'=>1000,}

def roman_to_integer(roman_string)
last = nil

roman_string.to_s.upcase.split(//).reverse.inject(0) do
|memo, digit|
if digit_value = DIGITS[digit]
if last && last > digit_value
memo -= digit_value
else
memo += digit_value
end
last = digit_value
end
memo
end
end

def method_missing(method)
str=method.id2name
roman_to_integer(str)
end
end

Calling the undefined methods

r= Roman.new
r.vii
r.iClx
r.xxix
r.xxxi
r.xxiv
r.xxvi
r.vx

The Output

Numeric Value for vii is: 7
Roman string is invalid
Numeric Value for xxix is: 29
Numeric Value for xxxi is: 31
Numeric Value for xxiv is: 24
Numeric Value for xxvi is: 26
Roman string is invalid

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The expected result would be a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-12T02:45:07Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://www.rubyquiz.com/quiz22.html */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Method Lookup Path'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://www.rubyquiz.com/quiz22.html</ref>===
class Roman
@@Roman_to_Numeric = {'i' => 1, 'v' => 5, 'x' => 10, 'l' => 50, 'c' => 100, 'd' => 500, 'm' => 1000}
def method_missing(method_var,*args,&block)
numeric_value = 0
roman_string = method_var.to_s.downcase
for i in 0...roman_string.length-1
if (cond) == nil
else
puts "Roman string is invalid"
return
end
end
while roman_string != ""
if roman_string[roman_string.length - 1] == 'x' && roman_string[roman_string.length - 2] == 'i'
numeric_value += 9
roman_string.chop!
roman_string.chop!
elsif
roman_string[roman_string.length - 1] == 'v' && roman_string[roman_string.length - 2] == 'i'
numeric_value += 4
roman_string.chop!
roman_string.chop!
else
numeric_value += @@Roman_to_Numeric[roman_string[(roman_string.length)-1]]
roman_string.chop!
end
end
puts "Numeric Value for #{method_var} is: #{numeric_value}"
end
end
'''cond''' = '''['''@@Roman_to_Numeric[roman_string[i]]-@@Roman_to_Numeric[roman_string[i+1]] == 0 || @@Roman_to_Numeric[roman_string[i]]-@@Roman _ to_ Numeric [ roman _ string [ i + 1 ] ] == - 9 || @@Roman_to_Numeric[roman_string[i]]-@@Roman_to_Numeric[roman_string[i+1]] == -4 || @@Roman_to_Numeric[roman_string[i]]-@@Roman_to_Numeric[roman_string[i+1]] >= 4) && (/.v.x/ =~ roman_string''']'''

Calling the undefined methods

r= Roman.new
r.vii
r.iClx
r.xxix
r.xxxi
r.xxiv
r.xxvi
r.vx

The Output

Numeric Value for vii is: 7
Roman string is invalid
Numeric Value for xxix is: 29
Numeric Value for xxxi is: 31
Numeric Value for xxiv is: 24
Numeric Value for xxvi is: 26
Roman string is invalid

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The expected result would be a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf

CSC/ECE 517 Fall 2012/ch1 1w22 an

2012-09-12T02:40:49Z

Asheikh: /* converting numbers from roman representation to integer representationhttp://www.rubyquiz.com/quiz22.html */

'''method_missing in Ruby:'''

=='''Introduction<ref>http://rubylearning.com/satishtalim/ruby_method_missing.html</ref>'''==
A method of a class is called by creating an object of the class and passing the method name to the object as a message. The object then looks up into its [http://www.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html method lookup path] and tries to match the called method with the defined methods in the class. On success, the method is executed along with the parameters passed and the result is returned.

If the object does not find a match in its method lookup, in normal circumstances the [http://www.ruby-doc.org/core-1.9.3/NoMethodError.html NoMethodError Exception] is raised .

“method_missing” is defined as a method in the class and is invoked if a called method is not found.

=='''Format for defining method_missing'''==

=> def method_missing(m,*args,&block)

(i) '''m->''' accepts the symbol/name of the undefined method (ii) '''*args->''' accepts the array of arguments passed in the method call (iii) '''&block->'''accepts a block passed to the method

=='''Method Lookup Path'''==
The object of a class receives a method name to be executed, the following steps are carried out for matching and executing the method:

*First, the object looks in its own [http://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html instance methods].
*Second, it looks in the list of instance methods that all objects of that class share.
*Third, in each of the included [http://www.tutorialspoint.com/ruby/ruby_modules.html modules] of that class, in reverse order of inclusion.
*Fourth, it looks in that class’s superclass.
*Fifth, in the superclass’s included modules, all the way up until it reaches the class Object.
*Sixth, if it still can’t find a method, the very last place it looks is in the [http://linux.die.net/lkmpg/x40.html Kernel module], included in the class Object.
*Finally, it calls method_missing (if defined in the class), else throws up the NOMethodError exception.

This entire tracing that the object does is the method lookup path.

=='''Examples'''==
===Calling defined and undefined methods===

class A // creating a class 'A'
def say // defining a method 'say'
puts " say Hi " // body of method say
end
end

Creating the object of the class

a=A.new // object of the class
=> #<A:0x2a082e0> //object id

Calling the defined method

a.say // defined method
=> say Hi // returned result

Calling the undefined method

a.sayhi // undefined method sayhi
NoMethodError: undefined method `sayhi' for #<A:0x2a082e0> // the NoMethodError is raised

===method_missing implementation<ref>http://www.thirdbit.net/articles/2007/08/01/10-things-you-should-know-about-method_missing/</ref>===

class A
def say
puts " say hi "
end
def method_missing(m,*args,&block) // defining method_missing
puts " This method does not exist" // body of method_missing
end
end

Calling a method that is not defined

a=A.new
a.sayhi // calling the undefined method sayhi with no arguments
=> This method does not exist // this result returned when method_missing is executed

When the object 'a' traces its method lookup path for a matching method as 'sayhi', upon failure it resorts to method_missing and the body of method_missing is executed. 'method_missing' is the last resort.

Sometimes when a class has many methods that do generally the same kinds of things, and the programmer is not sure in advance which methods the user will call since there are so many of them, and they are all so similar, implementing all of them by hand seems futile. In these situations method_missing makes a new method that was previously not defined and adds it to the class. The below 'Generic Handler' example implements this.

===passing parameters to an undefined method call===

class A
def add(a,b)
a+b
end
def method_missing(name,*args,&block) // the method_missing is defined and the *args parameter accepts all the parameters passed during
the method call
puts “You have typed the method name wrong and these were the parameters passed ; #{args[0]}, #{args[1]}”
end
end

The passed parameters are stored in the array 'args' and can be accessed like a normal array

Calling the defined method

a.add(1,2) // calling the defined method add and passing the parameters (1,2)
=> 3 // result

Calling the undefined method

a.adds(4,2) // calling the undefined method adds and passing the parameter (4,2)
=> You have typed the method name wrong and these were the parameters passed; 4, 2

The user made a genuine mistake by typing 'adds', but this method is not defined. When the 'adds' method with parameters is called, the object 'a' tries to match the method in the method lookup path. Upon failure it invokes method_missing, the args are passed, stored in the array 'args' and the body of method_missing is executed.

===converting numbers from roman representation to integer representation<ref>http://www.rubyquiz.com/quiz22.html</ref>===
class Roman
@@Roman_to_Numeric = {'i' => 1, 'v' => 5, 'x' => 10, 'l' => 50, 'c' => 100, 'd' => 500, 'm' => 1000}
def method_missing(method_var,*args,&block)
# code to convert from roman representation to integer representation

numeric_value = 0
roman_string = method_var.to_s.downcase
for i in 0...roman_string.length-1
if (cond) == nil
else
puts "Roman string is invalid"
return
end
end
while roman_string != ""
if roman_string[roman_string.length - 1] == 'x' && roman_string[roman_string.length - 2] == 'i'
numeric_value += 9
roman_string.chop!
roman_string.chop!
elsif
roman_string[roman_string.length - 1] == 'v' && roman_string[roman_string.length - 2] == 'i'
numeric_value += 4
roman_string.chop!
roman_string.chop!
else
numeric_value += @@Roman_to_Numeric[roman_string[(roman_string.length)-1]]
roman_string.chop!
end
end
puts "Numeric Value for #{method_var} is: #{numeric_value}"
end
end
'''cond''' = '''['''@@Roman_to_Numeric[roman_string[i]]-@@Roman_to_Numeric[roman_string[i+1]] == 0 || @@Roman_to_Numeric[roman_string[i]]-@@Roman _ to_ Numeric [ roman _ string [ i + 1 ] ] == - 9 || @@Roman_to_Numeric[roman_string[i]]-@@Roman_to_Numeric[roman_string[i+1]] == -4 || @@Roman_to_Numeric[roman_string[i]]-@@Roman_to_Numeric[roman_string[i+1]] >= 4) && (/.v.x/ =~ roman_string''']'''

Calling the undefined methods

r= Roman.new
r.vii
r.iClx
r.xxix
r.xxxi
r.xxiv
r.xxvi
r.vx

The Output

Numeric Value for vii is: 7
Roman string is invalid
Numeric Value for xxix is: 29
Numeric Value for xxxi is: 31
Numeric Value for xxiv is: 24
Numeric Value for xxvi is: 26
Roman string is invalid

===method_missing to log method calls<ref>http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2007/wiki1b_2_22</ref>===
Another application that makes use of method_missing could be a simple logger used for debugging purposes. Many times, it may be required to log the trace of called methods and provide information such as: called method-name, arguments, return type. It can be tedious to repeat this part of code in every method. A simple solution to this problem can be obtained using method_missing as:

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

This program makes use of method_missing in a way that it wraps around called method to output the logging information on entry and on exit, it logs the return type. Further, method_missing intercepts the method call and forward it to internal object with ‘send’ method of ruby. Hence, this use of method_missing acts as wrapper.

===Generic Handler===
class NoBar
def method_missing(methodname, *args)
define_method(:bar) if "bar" == methodname.to_s
define_method(:nobar) if "nobar" == methodname.to_s
end
end

This is an example of using method_missing as a generic handler to handle when a calling method is not exist. You can use missing_method to dynamically create a method at a runtime.

=='''Advantages of method_missing'''==

*In addition to specifying the error messages for the undefined methods, method_missing provides a more dynamic behavior in the programming environment.
*If we are unfamiliar with the usage of the objects we created, then using method_missing is a good technique.
*Handles problems at runtime.
*Define's a generic method_missing and handle's any undefined method, a big advantage over Java. In Java, when you call an undefined method, the program will not compile.
*method_missing falls under the general technique of [http://en.wikipedia.org/wiki/Metaprogramming meta-programming]. Employ meta-programming in missing_function to write an another function to handle the call.

=='''Disadvantages of method_missing'''==
*Slower than conventional method lookup. Simple tests indicate that method dispatch with method_missing is at least two to three times as expensive in time as conventional dispatch.

*Since the methods being called never actually exist—they are just intercepted at the last step of the method lookup process—they cannot be documented or introspected as conventional methods can.

*[http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html Dynamic methods] must go through the method_missing method, the body of that method can become quite large if there are many different aspects of the code that needs to add methods dynamically.

*method_missing restricts compatibility with future versions of an [http://en.wikipedia.org/wiki/Application_programming_interface API]. Introducing new methods in a future API version can break users' expectations.

=='''Key Points'''==
*Ruby knows method_missing( ) exisits, because it's a private instance method of 'BasicObject' that every object inherits. The BasicObject#method_missing( ) responds by raising the NoMethodError. Overriding this method_missing( ) allows you to call methods that don't really exist.

*If method_missing is only looking for certain method names, don't forget to call the [http://en.wikibooks.org/wiki/Java_Programming/Keywords/super super] keyword if you haven't found what you're looking for, so that the other superclass' method_missing can handle it.

*[http://www.prateekdayal.net/2007/10/16/rubys-responds_to-for-checking-if-a-method-exists/ obj.respond_to?] function returns 'true' if the obj responds to the given method. So if you want to know whether your class will respond to a function you can use respond_to? to know the answer. But if method_missing() is used, the output may not be what you expect.

*Below class A defines only method method_missing() and no other method. When a new object of class A tries to access a method say 'foo', the respond_to? will return the value 'false'. When you actually try to implement it using “a.foo”, the code will get executed, courtesy of method_missing(). Even though the respond_to? says that you cannot access 'foo' method using object of class A, if you have method_missing() defined, you can access the method.

class A
def method_missing(method_id)
puts "In method_missing"
end
end

a = A.new
puts a.respond_to?(:foo)
a.foo

Output
false
In method_missing

*If within method_missing() we define an undefined method.

class A
@@i = 0
def method_missing(method_id)
puts "In Method Missing #{@@i}"
@@i += 1
self.fun
end
end

a = A.new
puts a.respond_to?(:foo) // just checking whether the receiver 'a' responds to the method 'foo'

a.foo

Output

The expected result would be a 'stack level too deep' error.

When the 'foo' method is called, after no method match the method_missing is run and this block has a method “self.fun” that is undefined. Here when the program execution encounters 'self.fun' it once again calls method_missing. This goes on in an endless loop till the stack memory is full.

=='''References'''==
<references/>

=='''Further Suggested Reading'''==
*http://www.rubyinside.com/
*http://blog.jayfields.com/2008/02/ruby-replace-methodmissing-with-dynamic.html
*http://liquiddevelopment.blogspot.com/2006/04/twisting-and-shaping-dsls-using-ruby.html
*http://blog.rubybestpractices.com/posts/gregory/031-issue-2-method-lookup.html
*http://phrogz.net/RubyLibs/RubyMethodLookupFlow.pdf