Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T23:37:24Z

Amosti: /* Why use Protected Variation? */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

==How would you classify it ==

==Coding Examples==

The following are typical mechanisms which illustrate protected variations:

'''Polymorphism''':

In the below example from Larman's book, protected variations are illustrated via the use of polymorphism. Many tax calculator systems need to be integrated, and these external tax calculators provide for a point of instability in the program. Polymorphism allows for various ''ITaxCalculatorAdapter'' implementations to be created and collaborated with while protecting the system from variations in the external APIs.

[[Image:wiki3polymorphism.JPG]]

'''Inheritance''':

'''Indirection''':

==Confusion with Data Encapsulation==
While the concept of protected variations is similar to the concept of information hiding, it should not be confused with data encapsulation. Data encapsulation is merely a technique used to hide design information. Protected variations can involve many techniques wherein the overall goal is to protect code from other areas of the code which are decided to be highly volatile and likely to have the capability of adversely affecting the program.

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T23:36:29Z

Amosti: /* Coding Examples */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==

The following are typical mechanisms which illustrate protected variations:

'''Polymorphism''':

In the below example from Larman's book, protected variations are illustrated via the use of polymorphism. Many tax calculator systems need to be integrated, and these external tax calculators provide for a point of instability in the program. Polymorphism allows for various ''ITaxCalculatorAdapter'' implementations to be created and collaborated with while protecting the system from variations in the external APIs.

[[Image:wiki3polymorphism.JPG]]

'''Inheritance''':

'''Indirection''':

==Confusion with Data Encapsulation==
While the concept of protected variations is similar to the concept of information hiding, it should not be confused with data encapsulation. Data encapsulation is merely a technique used to hide design information. Protected variations can involve many techniques wherein the overall goal is to protect code from other areas of the code which are decided to be highly volatile and likely to have the capability of adversely affecting the program.

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T23:19:17Z

Amosti: /* Coding Examples */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==

The following are typical mechanisms which illustrate protected variations:

'''Polymorphism''':

In the below example from Larman's book, protected variations are illustrated via the use of polymorphism. Many tax calculator systems need to be integrated, and these external tax calculators provide for a point of instability in the program. Polymorphism allows for various ''ITaxCalculatorAdapter'' implementations to be created and collaborated with while protecting the system from variations in the external APIs.

[[Image:wiki3polymorphism.JPG]]

'''Inheritance''':

'''Indirection''':

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T22:55:43Z

Amosti: /* Coding Examples */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==

The following are typical mechanisms which illustrate protected variations:

'''Polymorphism''':

In the below example from Larman's book, protected variations are illustrated via the use of polymorphism. Many tax calculator systems need to be integrated, and these external tax calculators provide for a point of instability in the program. Polymorphism allows for various ''ITaxCalculatorAdapter'' implementations to be created and collaborated with while protecting the system from variations in the external APIs.

[[Image:wiki3polymorphism.JPG]]

'''Inheritance''':

'''Encapsulation''':

'''Indirection''':

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T22:53:18Z

Amosti: /* Coding Examples */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==
The typical mechanisms for protecting a system against variations.

Polymorphism:

In the below example from Larman's book, protected variations are illustrated via the use of polymorphism. Many tax calculator systems need to be integrated, and these external tax calculators provide for a point of instability in the program. Polymorphism allows for various ''ITaxCalculatorAdapter'' implementations to be created and collaborated with while protecting the system from variations in the external APIs.

[[Image:wiki3polymorphism.JPG]]

Inheritance example:

Encapsulation example:

Indirection example:

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T22:52:40Z

Amosti: /* Coding Examples */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==
The typical mechanisms for protecting a system against variations.

Polymorphism:
In the below example from Larman's book, protected variations are illustrated via the use of polymorphism. Many tax calculator systems need to be integrated, and these external tax calculators provide for a point of instability in the program. Polymorphism allows for various ''ITaxCalculatorAdapter'' implementations to be created and collaborated with while protecting the system from variations in the external APIs.

[[Image:wiki3polymorphism.JPG]]

Inheritance example:

Encapsulation example:

Indirection example:

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

File:Wiki3polymorphism.JPG

2008-07-26T22:31:46Z

Amosti:

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T22:29:51Z

Amosti: /* ''References'' */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==
The typical mechanisms for protecting a system against variations.

Polymorphism example:

Inheritance example:

Encapsulation example:

Indirection example:

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.

Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T22:29:19Z

Amosti: /* ''References'' */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==
The typical mechanisms for protecting a system against variations.

Polymorphism example:

Inheritance example:

Encapsulation example:

Indirection example:

==Conclusion==

==''References''==
Larman, Craig. [http://books.google.com/books?id=r8i-4En_aa4C Applying UML and Patterns]. Prentice Hall PTR, 2001.
Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T22:10:00Z

Amosti: /* Introduction */

==Protected Variation==

The term protected variations comes from the need for the programmer to predict what in the code is likely vary in future adaptions of the code and prevent those variations from damaging the intended functionality of the code. At some time in the future the code is likely going to need additional functionality. The adding of functionality should not prevent the sections of code that currently work from continuing to do so while also allowing the new code to integrate and use the existing structure efficiently.

Protected variation is often linked to the Open-Closed Principle (OCP) and Information Hiding which all tend to have a final goal of code that is adaptable without damaging the integrity of original code and without alterations beyond additions to the original code.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

The term Open-Closed Principal is credited to having orginated from Dr. Bertrand Meyer and appears in his 1988 book Object Oriented Software Construction. This original version of the Open-Closed Principle achieved protection from variation by relying heavily on original class inheritance. This is often referred to as the Meyer's Open-Closed Principle.

In more recent years the Open-Closed principle is linked more closely to the use of polymorphism to achieve protection from variations. In this system abstract interfaces are commonly used and multitudes of implementations are used polymorphically as substitutes for the existing implementation which leaves the original code intact and operating as intended.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==
The typical mechanisms for protecting a system against variations.

Polymorphism example:

Inheritance example:

Encapsulation example:

Indirection example:

==Conclusion==

==''References''==
Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T15:59:14Z

Amosti: /* Why use Protected Variation? */

==Protected Variation==
Open-Closed Principle
"Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification [Martin, p.99]"

Description of protected variation

Protected variation and Polymorphism
Protected Variation and Polymorphism seem related. What is the difference
between the two? Where would you apply one pattern over the other?

Polymorphism is a powerful technology that is very useful for
handling Protected Variation. Protected Variation gives one reason "why"
for a particular use of Polymorphism.

An example of an
.Key Open-Closed Principle
is... X can be opened to Y and always Z. And it's only open to Y if it Y
needs to access something and has permission to. While Z can always access
it because it has permission to.
That look right?

I'd express it like this: if X uses Y in some way or other you don't want
changes to Y to effect X, but you also want to be able to change Y in ways
that don't change X.

Open-closed principle
“Software should be open to extension but closed to modification” (Bertrand Meyer). The idea is to
enhance functionality by making non-intrusive changes. Intrusive changes are changes that alter code that
has been previously written; changing inside of classes. Rather, interfaces should be changed/extended
rather than the implementation of classes.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

== Why use Protected Variation? ==
Protected Variation is a principle which can save much time and money. It is important to reduce the introduction of new defects, and in order to do so, the impact of change to a piece of code on the overall program must be minimized. Protected Variations help to introduce low coupling (i.e. minimizing the degree to which each program module relies on each one of the other modules), which in turn reduce change impact.

* Example 1

* Example 2

==How would you classify it ==

==Coding Examples==

==Conclusion==

==''References''==
Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T15:36:35Z

Amosti: /* Introduction */

==Protected Variation==
Open-Closed Principle
"Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification [Martin, p.99]"

Description of protected variation

Protected variation and Polymorphism
Protected Variation and Polymorphism seem related. What is the difference
between the two? Where would you apply one pattern over the other?

Polymorphism is a powerful technology that is very useful for
handling Protected Variation. Protected Variation gives one reason "why"
for a particular use of Polymorphism.

An example of an
.Key Open-Closed Principle
is... X can be opened to Y and always Z. And it's only open to Y if it Y
needs to access something and has permission to. While Z can always access
it because it has permission to.
That look right?

I'd express it like this: if X uses Y in some way or other you don't want
changes to Y to effect X, but you also want to be able to change Y in ways
that don't change X.

Open-closed principle
“Software should be open to extension but closed to modification” (Bertrand Meyer). The idea is to
enhance functionality by making non-intrusive changes. Intrusive changes are changes that alter code that
has been previously written; changing inside of classes. Rather, interfaces should be changed/extended
rather than the implementation of classes.

== Introduction ==
When programming code, care should be made to protect against change to the existing code. Information should be kept out of the grasp of components that could damage integrity. New design should be implemented at designated "variation" and "evolution" points. The pattern of ''Protected Variation'' involves identifying points of predicted variation and creating a stable interface around them.

Protected Variation is closely knitted with the Open-Closed Principle. When points of predicted variation are identified, the code becomes easy to extend/adapt ("open"), while the stable interfaces around these points provides for "closed" code, wherein modification will not affect clients. This stable interface surrounding the points of change also promotes the concept of Information Hiding, in that design information is hidden from other modules at the points of likely change.

== Why use Protected Variation? ==
General overview

* Example 1

* Example 2
==How would you classify it ==

==Coding Examples==

==Conclusion==

==''References''==
Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T15:09:19Z

Amosti: /* Conclusion */

==Protected Variation==
Open-Closed Principle
"Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification [Martin, p.99]"

Description of protected variation

Protected variation and Polymorphism
Protected Variation and Polymorphism seem related. What is the difference
between the two? Where would you apply one pattern over the other?

Polymorphism is a powerful technology that is very useful for
handling Protected Variation. Protected Variation gives one reason "why"
for a particular use of Polymorphism.

An example of an
.Key Open-Closed Principle
is... X can be opened to Y and always Z. And it's only open to Y if it Y
needs to access something and has permission to. While Z can always access
it because it has permission to.
That look right?

I'd express it like this: if X uses Y in some way or other you don't want
changes to Y to effect X, but you also want to be able to change Y in ways
that don't change X.

Open-closed principle
“Software should be open to extension but closed to modification” (Bertrand Meyer). The idea is to
enhance functionality by making non-intrusive changes. Intrusive changes are changes that alter code that
has been previously written; changing inside of classes. Rather, interfaces should be changed/extended
rather than the implementation of classes.

== Introduction ==
Keep information out of the grasp of components that could damage integrity.
Introduce reader to protected variation -Open/Closed Principle and Information Hiding

== Why use Protected Variation? ==
General overview

* Example 1

* Example 2
==How would you classify it ==

==Coding Examples==

==Conclusion==

==''References''==
Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==''External Links''==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 6 esb

2008-07-26T14:42:58Z

Amosti: /* Conclusion */

==Protected Variation==
Open-Closed Principle
"Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification [Martin, p.99]"

Description of protected variation

Protected variation and Polymorphism
Protected Variation and Polymorphism seem related. What is the difference
between the two? Where would you apply one pattern over the other?

Polymorphism is a powerful technology that is very useful for
handling Protected Variation. Protected Variation gives one reason "why"
for a particular use of Polymorphism.

An example of an
.Key Open-Closed Principle
is... X can be opened to Y and always Z. And it's only open to Y if it Y
needs to access something and has permission to. While Z can always access
it because it has permission to.
That look right?

I'd express it like this: if X uses Y in some way or other you don't want
changes to Y to effect X, but you also want to be able to change Y in ways
that don't change X.

Open-closed principle
“Software should be open to extension but closed to modification” (Bertrand Meyer). The idea is to
enhance functionality by making non-intrusive changes. Intrusive changes are changes that alter code that
has been previously written; changing inside of classes. Rather, interfaces should be changed/extended
rather than the implementation of classes.

== Introduction ==
Keep information out of the grasp of components that could damage integrity.
Introduce reader to protected variation -Open/Closed Principle and Information Hiding

== Why use Protected Variation? ==
General overview

* Example 1

* Example 2
==How would you classify it ==

==Coding Examples==

=Conclusion=

==See Also==

==References==
Larman, Craig. [http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/iel5/52/19948/00922731.pdf?tp=&arnumber=922731&isnumber=19948 Protected Variation: The Importance of Being Closed]. IEEE Software 18.3 (2001): 89-91.

==External links==

http://codecourse.sourceforge.net/materials/The-Importance-of-Being-Closed.pdf

http://www.rgoarchitects.com/Files/ooprimer.ppt#288,9,OCP Example

http://www.cs.wright.edu/~tkprasad/courses/cs480/L3OOP.pdf

http://www.csci.csusb.edu/dick/cs375/16q.txt

http://www.cs.wustl.edu/~schmidt/PDF/design-principles4.pdf

http://davidhayden.com/blog/dave/archive/2005/06/04/1096.aspx

http://en.wikipedia.org/wiki/GRASP_(Object_Oriented_Design)

http://en.wikipedia.org/wiki/Open/closed_principle

http://www.openmymind.net/FoundationsOfProgramming.pdf

http://www.cs.umu.se/kurser/TDBC31/Overheads/L8-10_Advanced.pdf

http://www.nationmaster.com/encyclopedia/Open-Closed-Principle

Good General link:
http://www.netobjectives.com/resources/books/design-patterns-explained/review-questions

Next very good:
http://www.augustana.ab.ca/~mohrj/courses/2007.fall/csc220/presentations/25_GRASP2.ppt#270,5,Fig. 25.2 Applying polymorphism to Monopoly

http://www.nationmaster.com/encyclopedia/Information-hiding

http://www.rgoarchitects.com/nblog/CategoryView,category,ruby.aspx

http://www.cse.ohio-state.edu/~rountev/757/pdf/Principles.pdf

[[CSC/ECE 517 Summer 2008/wiki3 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T02:52:36Z

Amosti: /* Hungarian notation */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. It's always important to choose descriptive names with straightforward meanings. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== Naming conventions advantages ===
* to provide additional information (ie, metadata) about the use to which an identifier is put
* to help formalize expectations and promote consistency within a development team
* to enable the use of automated refactoring or search and replace tools with minimal potential for error
* to enhance clarity in cases of potential ambiguity
* to enhance the aesthetic and professional appearance of work product (for example, by disallowing overly long names, comical or "cute" names, or abbreviations)
* to help avoid "naming collisions" that might occur when the work product of different organizations is combined
* to provide meaningful data to be used in project handovers which require submission of program source code and all relevant documentation

=== Naming conventions disadvantages ===
* When a variable type is changed, you may have to go through and change ''all'' the instances of that variable within your code. The find-and-replace feature of many editors alleviates this issue a bit, but it may still be tedious.
* If your language changes, i.e. is updated, code may need to be changed so the naming convention still fits.
* Naming conventions may defeat the purpose of encapsulation. The "black box" aspect is eliminated when the programmer needs to know what specific type is being returned.

=== Common conventions ===
* Packages should have prefixes always written in all-lowercase ASCII letters and they should be one of the top-level domain names, currently com, edu, gov, mil, net, org, or one of the English two-letter codes identifying countries as specified in ISO Standard 3166, 1981. Examples: <tt>com.sun.eng</tt>, <tt>com.apple.quicktime.v2</tt>, and <tt>edu.cmu.cs.bovik.cheese</tt>.
* Class names should be nouns, in mixed case with the first letter of each word capitalized. They should be simple and descriptive, and whole words should be used (avoid acronyms and abbreviations). Examples: <tt>class Roster;</tt>, <tt>class ImageSprite;</tt>.
* Interface names should be capitalized like class names. Examples: <tt>interface RosterDelegate;</tt>, <tt>interface Storing;</tt>.
* Lowercase letters should be used for variable and method names. A name consisting of several words should be concatenated into one word (take out the spaces). The first word should be all lowercase, and each subsequent word (the internal words) should have its first letter capitalized. Methods should be verbs. Examples: <tt>run();</tt>, <tt>runFast();</tt>, and <tt>getBackground();</tt>
* Variable names should be short yet meaningful. The choice of a variable name should be mnemonic- that is, designed to indicate to the casual observer the intent of its use. One-character variable names should be avoided except for temporary "throwaway" variables. Common names for temporary variables are i, j, k, m, and n for integers; c, d, and e for characters. Variable names should not start with underscore ("<tt>_</tt>") or dollar sign ("<tt>$</tt>") characters, even though both are allowed. Examples: <tt>int i;</tt>, <tt>char c;</tt>, and <tt>float myWidth;</tt>.
* The names of variables declared ''class constants'' and of ''ANSI constants'' should be all uppercase with words separated by underscores ("<tt>_</tt>"). Examples: <tt>static final int MIN_WIDTH = 4;</tt>, <tt>static final int MAX_WIDTH = 999;</tt>, and <tt>static final int GET_THE_CPU = 1;</tt>.

=== Hungarian notation ===

One of the most popular naming conventions is Hungarian notation, which encodes either the purpose ("Apps Hungarian") or the type ("Systems Hungarian") of a variable in its name. Some examples of "Apps Hungarian" are:
* <tt>rwPosition</tt>: variable represents a row ("rw")
* <tt>usName</tt>: variable represents an unsafe string ("us"), which needs to be "sanitized" before it is used
* <tt>strName</tt>: Variable represents a string ("str") containing the name, but does not specify how that string is implemented

Some examples of "Apps Hungarian" are as follows:
* <tt>lAccountNum</tt>: variable is a long integer ("l")
* <tt>arru8NumberList</tt>: variable is an array of unsigned 8-bit integers ("arru8")
* <tt>szName</tt>: variable is a zero-terminated string ("sz")

=== Final conclusions ===
The advantages of using naming conventions outweigh the disadvantages. Readability is the biggest derived benefit, and its importance cannot be overstated. Variable types, as well as their purpose (for classes and modules too) can be determined at a quick glance. Readers unfamiliar with the code can derive meaning and purpose quicker, without having to study large portions of the code and refer to various places within. The following tips should be used when choosing names for variables, classes, modules, etc.:

* Prefix the variable names with their scope and their data types
* Use meaningful variable names
* Be wary of long names
* Use your conventions consistently

=== ''References'' ===
* Liang, Y. Daniel. [http://books.google.com/books?id=juuPxtSCg50C Introduction to Java Programming: Comprehensive]. Pearson Prentice Hall, 2008.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html
* http://en.wikipedia.org/wiki/Identifier_naming_convention
* http://www.erlang.se/doc/programming_rules.shtml

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T02:50:32Z

Amosti: /* Variable, Class, and Module Naming */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. It's always important to choose descriptive names with straightforward meanings. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== Naming conventions advantages ===
* to provide additional information (ie, metadata) about the use to which an identifier is put
* to help formalize expectations and promote consistency within a development team
* to enable the use of automated refactoring or search and replace tools with minimal potential for error
* to enhance clarity in cases of potential ambiguity
* to enhance the aesthetic and professional appearance of work product (for example, by disallowing overly long names, comical or "cute" names, or abbreviations)
* to help avoid "naming collisions" that might occur when the work product of different organizations is combined
* to provide meaningful data to be used in project handovers which require submission of program source code and all relevant documentation

=== Naming conventions disadvantages ===
* When a variable type is changed, you may have to go through and change ''all'' the instances of that variable within your code. The find-and-replace feature of many editors alleviates this issue a bit, but it may still be tedious.
* If your language changes, i.e. is updated, code may need to be changed so the naming convention still fits.
* Naming conventions may defeat the purpose of encapsulation. The "black box" aspect is eliminated when the programmer needs to know what specific type is being returned.

=== Common conventions ===
* Packages should have prefixes always written in all-lowercase ASCII letters and they should be one of the top-level domain names, currently com, edu, gov, mil, net, org, or one of the English two-letter codes identifying countries as specified in ISO Standard 3166, 1981. Examples: <tt>com.sun.eng</tt>, <tt>com.apple.quicktime.v2</tt>, and <tt>edu.cmu.cs.bovik.cheese</tt>.
* Class names should be nouns, in mixed case with the first letter of each word capitalized. They should be simple and descriptive, and whole words should be used (avoid acronyms and abbreviations). Examples: <tt>class Roster;</tt>, <tt>class ImageSprite;</tt>.
* Interface names should be capitalized like class names. Examples: <tt>interface RosterDelegate;</tt>, <tt>interface Storing;</tt>.
* Lowercase letters should be used for variable and method names. A name consisting of several words should be concatenated into one word (take out the spaces). The first word should be all lowercase, and each subsequent word (the internal words) should have its first letter capitalized. Methods should be verbs. Examples: <tt>run();</tt>, <tt>runFast();</tt>, and <tt>getBackground();</tt>
* Variable names should be short yet meaningful. The choice of a variable name should be mnemonic- that is, designed to indicate to the casual observer the intent of its use. One-character variable names should be avoided except for temporary "throwaway" variables. Common names for temporary variables are i, j, k, m, and n for integers; c, d, and e for characters. Variable names should not start with underscore ("<tt>_</tt>") or dollar sign ("<tt>$</tt>") characters, even though both are allowed. Examples: <tt>int i;</tt>, <tt>char c;</tt>, and <tt>float myWidth;</tt>.
* The names of variables declared ''class constants'' and of ''ANSI constants'' should be all uppercase with words separated by underscores ("<tt>_</tt>"). Examples: <tt>static final int MIN_WIDTH = 4;</tt>, <tt>static final int MAX_WIDTH = 999;</tt>, and <tt>static final int GET_THE_CPU = 1;</tt>.

=== Hungarian notation ===

One of the most popular naming conventions is Hungarian notation, which encodes either the purpose ("Apps Hungarian") or the type ("Systems Hungarian") of a variable in its name. Some examples of "Systems Hungarian" are:
* <tt>lAccountNum</tt>: variable is a long integer ("l")
* <tt>arru8NumberList</tt>: variable is an array of unsigned 8-bit integers ("arru8")
* <tt>szName</tt>: variable is a zero-terminated string ("sz")

Some examples of "Apps Hungarian" are as follows:
* <tt>rwPosition</tt>: variable represents a row ("rw")
* <tt>usName</tt>: variable represents an unsafe string ("us"), which needs to be "sanitized" before it is used
* <tt>strName</tt>: Variable represents a string ("str") containing the name, but does not specify how that string is implemented

=== Final conclusions ===
The advantages of using naming conventions outweigh the disadvantages. Readability is the biggest derived benefit, and its importance cannot be overstated. Variable types, as well as their purpose (for classes and modules too) can be determined at a quick glance. Readers unfamiliar with the code can derive meaning and purpose quicker, without having to study large portions of the code and refer to various places within. The following tips should be used when choosing names for variables, classes, modules, etc.:

* Prefix the variable names with their scope and their data types
* Use meaningful variable names
* Be wary of long names
* Use your conventions consistently

=== ''References'' ===
* Liang, Y. Daniel. [http://books.google.com/books?id=juuPxtSCg50C Introduction to Java Programming: Comprehensive]. Pearson Prentice Hall, 2008.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html
* http://en.wikipedia.org/wiki/Identifier_naming_convention
* http://www.erlang.se/doc/programming_rules.shtml

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T02:36:31Z

Amosti: /* Common conventions */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. It's always important to choose descriptive names with straightforward meanings. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== Naming conventions advantages ===
* to provide additional information (ie, metadata) about the use to which an identifier is put
* to help formalize expectations and promote consistency within a development team
* to enable the use of automated refactoring or search and replace tools with minimal potential for error
* to enhance clarity in cases of potential ambiguity
* to enhance the aesthetic and professional appearance of work product (for example, by disallowing overly long names, comical or "cute" names, or abbreviations)
* to help avoid "naming collisions" that might occur when the work product of different organizations is combined
* to provide meaningful data to be used in project handovers which require submission of program source code and all relevant documentation

=== Naming conventions disadvantages ===
* When a variable type is changed, you may have to go through and change ''all'' the instances of that variable within your code. The find-and-replace feature of many editors alleviates this issue a bit, but it may still be tedious.
* If your language changes, i.e. is updated, code may need to be changed so the naming convention still fits.
* Naming conventions may defeat the purpose of encapsulation. The "black box" aspect is eliminated when the programmer needs to know what specific type is being returned.

=== Common conventions ===
* Packages should have prefixes always written in all-lowercase ASCII letters and they should be one of the top-level domain names, currently com, edu, gov, mil, net, org, or one of the English two-letter codes identifying countries as specified in ISO Standard 3166, 1981. Examples: <tt>com.sun.eng</tt>, <tt>com.apple.quicktime.v2</tt>, and <tt>edu.cmu.cs.bovik.cheese</tt>.
* Class names should be nouns, in mixed case with the first letter of each word capitalized. They should be simple and descriptive, and whole words should be used (avoid acronyms and abbreviations). Examples: <tt>class Roster;</tt>, <tt>class ImageSprite;</tt>.
* Interface names should be capitalized like class names. Examples: <tt>interface RosterDelegate;</tt>, <tt>interface Storing;</tt>.
* Lowercase letters should be used for variable and method names. A name consisting of several words should be concatenated into one word (take out the spaces). The first word should be all lowercase, and each subsequent word (the internal words) should have its first letter capitalized. Methods should be verbs. Examples: <tt>run();</tt>, <tt>runFast();</tt>, and <tt>getBackground();</tt>
* Variable names should be short yet meaningful. The choice of a variable name should be mnemonic- that is, designed to indicate to the casual observer the intent of its use. One-character variable names should be avoided except for temporary "throwaway" variables. Common names for temporary variables are i, j, k, m, and n for integers; c, d, and e for characters. Variable names should not start with underscore ("<tt>_</tt>") or dollar sign ("<tt>$</tt>") characters, even though both are allowed. Examples: <tt>int i;</tt>, <tt>char c;</tt>, and <tt>float myWidth;</tt>.
* The names of variables declared ''class constants'' and of ''ANSI constants'' should be all uppercase with words separated by underscores ("<tt>_</tt>"). Examples: <tt>static final int MIN_WIDTH = 4;</tt>, <tt>static final int MAX_WIDTH = 999;</tt>, and <tt>static final int GET_THE_CPU = 1;</tt>.

=== Final conclusions ===
The advantages of using naming conventions outweigh the disadvantages. Readability is the biggest derived benefit, and its importance cannot be overstated. Variable types, as well as their purpose (for classes and modules too) can be determined at a quick glance. Readers unfamiliar with the code can derive meaning and purpose quicker, without having to study large portions of the code and refer to various places within. The following tips should be used when choosing names for variables, classes, modules, etc.:

* Prefix the variable names with their scope and their data types
* Use meaningful variable names
* Be wary of long names
* Use your conventions consistently

=== ''References'' ===
* Liang, Y. Daniel. [http://books.google.com/books?id=juuPxtSCg50C Introduction to Java Programming: Comprehensive]. Pearson Prentice Hall, 2008.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html
* http://en.wikipedia.org/wiki/Identifier_naming_convention
* http://www.erlang.se/doc/programming_rules.shtml

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T02:35:02Z

Amosti: /* Common conventions */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. It's always important to choose descriptive names with straightforward meanings. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== Naming conventions advantages ===
* to provide additional information (ie, metadata) about the use to which an identifier is put
* to help formalize expectations and promote consistency within a development team
* to enable the use of automated refactoring or search and replace tools with minimal potential for error
* to enhance clarity in cases of potential ambiguity
* to enhance the aesthetic and professional appearance of work product (for example, by disallowing overly long names, comical or "cute" names, or abbreviations)
* to help avoid "naming collisions" that might occur when the work product of different organizations is combined
* to provide meaningful data to be used in project handovers which require submission of program source code and all relevant documentation

=== Naming conventions disadvantages ===
* When a variable type is changed, you may have to go through and change ''all'' the instances of that variable within your code. The find-and-replace feature of many editors alleviates this issue a bit, but it may still be tedious.
* If your language changes, i.e. is updated, code may need to be changed so the naming convention still fits.
* Naming conventions may defeat the purpose of encapsulation. The "black box" aspect is eliminated when the programmer needs to know what specific type is being returned.

=== Common conventions ===
* Packages should have prefixes always written in all-lowercase ASCII letters and they should be one of the top-level domain names, currently com, edu, gov, mil, net, org, or one of the English two-letter codes identifying countries as specified in ISO Standard 3166, 1981. Examples: <tt>com.sun.eng</tt>, <tt>com.apple.quicktime.v2</tt>, and <tt>edu.cmu.cs.bovik.cheese</tt>.
* Class names should be nouns, in mixed case with the first letter of each word capitalized. They should be simple and descriptive, and whole words should be used (avoid acronyms and abbreviations). Examples: <tt>class Roster;</tt>, <tt>class ImageSprite;</tt>.
* Interface names should be capitalized like class names. Examples: <tt>interface RosterDelegate;</tt>, <tt>interface Storing;</tt>.
* Lowercase letters should be used for variable and method names. A name consisting of several words should be concatenated into one word (take out the spaces). The first word should be all lowercase, and each subsequent word (the internal words) should have its first letter capitalized. Methods should be verbs. Examples: <tt>run();</tt>, <tt>runFast();</tt>, and <tt>getBackground();</tt>
* Variable names should be short yet meaningful. The choice of a variable name should be mnemonic- that is, designed to indicate to the casual observer the intent of its use. One-character variable names should be avoided except for temporary "throwaway" variables. Common names for temporary variables are i, j, k, m, and n for integers; c, d, and e for characters. Variable names should not start with underscore ("<tt>_</tt>") or dollar sign ("<tt>$</tt>") characters, even though both are allowed. Examples: <tt>int i;</tt>, <tt>char c;</tt>, and <tt>float myWidth;</tt>.
* The names of variables declared ''class constants'' and of ''ANSI constants'' should be all uppercase with words separated by underscores ("<tt>_</tt>"). (ANSI constants should be avoided, for ease of debugging.) Examples: <tt>static final int MIN_WIDTH = 4;</tt>, <tt>static final int MAX_WIDTH = 999;</tt>, and <tt>static final int GET_THE_CPU = 1;</tt>.

=== Final conclusions ===
The advantages of using naming conventions outweigh the disadvantages. Readability is the biggest derived benefit, and its importance cannot be overstated. Variable types, as well as their purpose (for classes and modules too) can be determined at a quick glance. Readers unfamiliar with the code can derive meaning and purpose quicker, without having to study large portions of the code and refer to various places within. The following tips should be used when choosing names for variables, classes, modules, etc.:

* Prefix the variable names with their scope and their data types
* Use meaningful variable names
* Be wary of long names
* Use your conventions consistently

=== ''References'' ===
* Liang, Y. Daniel. [http://books.google.com/books?id=juuPxtSCg50C Introduction to Java Programming: Comprehensive]. Pearson Prentice Hall, 2008.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html
* http://en.wikipedia.org/wiki/Identifier_naming_convention
* http://www.erlang.se/doc/programming_rules.shtml

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T01:47:39Z

Amosti: /* Final conclusions and tips */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T01:40:53Z

Amosti: /* Variable, Class, and Module Naming */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T01:33:46Z

Amosti: /* Naming conventions disadvantages */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-26T01:24:01Z

Amosti: /* Variable, Class, and Module Naming */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T18:42:07Z

Amosti: /* ''External Links'' */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T18:40:54Z

Amosti: /* Variable, Class, and Module Naming */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T18:28:55Z

Amosti: /* References */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== ''References'' ===
* Liang, Y. Daniel. [http://books.google.com/books?id=juuPxtSCg50C Introduction to Java Programming: Comprehensive]. Pearson Prentice Hall, 2008.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T18:28:20Z

Amosti: /* Variable, Class, and Module Naming */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== References ===
* Liang, Y. Daniel. [http://books.google.com/books?id=juuPxtSCg50C Introduction to Java Programming: Comprehensive]. Pearson Prentice Hall, 2008.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T18:13:22Z

Amosti: /* ''External Links'' */

== Variable, Class, and Module Naming ==

When programming, choosing appropriate names for variables, classes, modules, etc. can often be taken too lightly. Certain conventions should be followed to ensure code can be read, followed, and edited easily.

=== ''External Links'' ===
* http://frontier.userland.com/tutorial/variableNaming
* http://www.programmers-corner.com/article/18
* http://java.sun.com/docs/codeconv/html/CodeConventions.doc8.html
* http://www.cprogramming.com/tutorial/style_naming_conventions.html
* http://www.uwe-sauerland.de/richtlinien/naming.html
* http://www.kamath.com/columns/squareone/so001_whatname1.asp
* http://java.sun.com/docs/books/tutorial/java/nutsandbolts/variables.html

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:52:39Z

Amosti: /* ''External Links'' */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:51:02Z

Amosti: /* Variable, Class, and Module Naming */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:49:47Z

Amosti: /* Variable, Class, and Module Naming */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:43:52Z

Amosti: /* Variable, Class, and Module Naming */

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:29:47Z

Amosti: /* Variable, Class, and Module Naming */

== Variable, Class, and Module Naming ==

=== Introduction ===

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:29:31Z

Amosti: /* Introduction */

= Variable, Class, and Module Naming =

=== Introduction ===

CSC/ECE 517 Summer 2008/wiki2 2 ao

2008-06-25T17:26:07Z

Amosti:

== Introduction ==

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-12T03:02:18Z

Amosti: /* What is ''Reflection'' in computer science? */

== Reflection in Ruby and Java ==
;
===What is ''Reflection'' in computer science?===

{| border="0" cellpadding="0"
|width="550"|Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.
|width="50"|
|width="200"|[[Image:linear.png|Reflection]]
|}

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {

/** The main method. Print info about the named class */

public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */

public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.

if (c.isInterface()) {

// The modifiers will include the "interface" keyword here...

System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.

Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.

System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */

public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */

public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */

public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */

public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

'''This code is then compiled and run, with the following simple test class passed in:'''

<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>

'''The output generated is as follows:'''

<pre>
public class testInput extends java.lang.Object {

// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*Language facilities such as ''aliasing'', ''reflection'', and ''metaprogramming'' make Aspect Oriented Programming much easier to perform in Ruby than in Java.

=== Uses of Reflection ===
Reflection is used by programs which require the ability to analyze or modify the runtime behavior of applications.This is a relatively advanced feature.Thus, reflection is a powerful technique which can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features:
An application may utilize external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser could enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers could examine private members on classes. Test harnesses could use reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

*Performance Overhead
Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

*Exposure of Internals
Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-12T03:00:53Z

Amosti: /* What is ''Reflection'' in computer science? */

== Reflection in Ruby and Java ==
;
===What is ''Reflection'' in computer science?===

{| border="0" cellpadding="0"
|width="550"|Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.
|width="50"|
|width="200"|[[Image:linear.png]]
|}

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {

/** The main method. Print info about the named class */

public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */

public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.

if (c.isInterface()) {

// The modifiers will include the "interface" keyword here...

System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.

Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.

System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */

public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */

public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */

public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */

public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

'''This code is then compiled and run, with the following simple test class passed in:'''

<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>

'''The output generated is as follows:'''

<pre>
public class testInput extends java.lang.Object {

// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*Language facilities such as ''aliasing'', ''reflection'', and ''metaprogramming'' make Aspect Oriented Programming much easier to perform in Ruby than in Java.

=== Uses of Reflection ===
Reflection is used by programs which require the ability to analyze or modify the runtime behavior of applications.This is a relatively advanced feature.Thus, reflection is a powerful technique which can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features:
An application may utilize external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser could enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers could examine private members on classes. Test harnesses could use reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

*Performance Overhead
Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

*Exposure of Internals
Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-12T02:42:52Z

Amosti: /* What is ''Reflection'' in computer science? */

== Reflection in Ruby and Java ==
;
===What is ''Reflection'' in computer science?===
<center>[[Image:linear.png]]</center>
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {

/** The main method. Print info about the named class */

public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */

public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.

if (c.isInterface()) {

// The modifiers will include the "interface" keyword here...

System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.

Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.

System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */

public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */

public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */

public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */

public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

'''This code is then compiled and run, with the following simple test class passed in:'''

<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>

'''The output generated is as follows:'''

<pre>
public class testInput extends java.lang.Object {

// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*Language facilities such as ''aliasing'', ''reflection'', and ''metaprogramming'' make Aspect Oriented Programming much easier to perform in Ruby than in Java.

=== Uses of Reflection ===
Reflection is used by programs which require the ability to analyze or modify the runtime behavior of applications.This is a relatively advanced feature.Thus, reflection is a powerful technique which can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features:
An application may utilize external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser could enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers could examine private members on classes. Test harnesses could use reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

*Performance Overhead
Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

*Exposure of Internals
Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-12T02:42:26Z

Amosti: /* What is ''Reflection'' in computer science? */

== Reflection in Ruby and Java ==
;
===What is ''Reflection'' in computer science?===
[[Image:linear.png]]
<center>[[Image:linear.png]]</center>
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {

/** The main method. Print info about the named class */

public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */

public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.

if (c.isInterface()) {

// The modifiers will include the "interface" keyword here...

System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.

Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.

System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */

public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */

public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */

public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */

public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

'''This code is then compiled and run, with the following simple test class passed in:'''

<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>

'''The output generated is as follows:'''

<pre>
public class testInput extends java.lang.Object {

// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*Language facilities such as ''aliasing'', ''reflection'', and ''metaprogramming'' make Aspect Oriented Programming much easier to perform in Ruby than in Java.

=== Uses of Reflection ===
Reflection is used by programs which require the ability to analyze or modify the runtime behavior of applications.This is a relatively advanced feature.Thus, reflection is a powerful technique which can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features:
An application may utilize external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser could enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers could examine private members on classes. Test harnesses could use reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

*Performance Overhead
Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

*Exposure of Internals
Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-12T02:18:01Z

Amosti: /* Ruby Reflection vs. Java Reflection */

== Reflection in Ruby and Java ==
;[[Image:Example.jpg]]What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {

/** The main method. Print info about the named class */

public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */

public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.

if (c.isInterface()) {

// The modifiers will include the "interface" keyword here...

System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.

Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.

System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */

public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */

public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */

public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */

public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

'''This code is then compiled and run, with the following simple test class passed in:'''

<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>

'''The output generated is as follows:'''

<pre>
public class testInput extends java.lang.Object {

// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*Language facilities such as ''aliasing'', ''reflection'', and ''metaprogramming'' make Aspect Oriented Programming much easier to perform in Ruby than in Java.

=== Uses of Reflection ===
Reflection is used by programs which require the ability to analyze or modify the runtime behavior of applications.This is a relatively advanced feature.Thus, reflection is a powerful technique which can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features:
An application may utilize external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser could enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers could examine private members on classes. Test harnesses could use reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

*Performance Overhead
Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

*Exposure of Internals
Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-12T01:28:27Z

Amosti: /* Drawbacks of Reflection */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing'', ''reflection'', and ''metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. It is preferable to avoid using reflection, if possible. The following concerns should be kept in mind when accessing code via reflection:

*Performance Overhead
Certain Java virtual machine optimizations, which greatly increase performance in Java applications, cannot be performed when reflective operations are used due to the dynamically resolved types involved in reflection. Therefore, reflection should be avoided in sections of code called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is important for code running in a restricted security contect, e.g. in an Applet.

*Exposure of Internals
Operations which would be illegal in a non-reflective environment, such as accessing private fields and methods, are allowed in reflective code. Consequently, unexpected side-effects, which may render code dysfunctional and destroy portability, may result from the use of reflection. Abstractions may also be broken, thus changing behavior with platform upgrades.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T17:48:12Z

Amosti: /* Ruby Reflection vs. Java Reflection */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby efficiency when looking inside classes.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing'', ''reflection'', and ''metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T17:47:58Z

Amosti: /* Ruby Reflection vs. Java Reflection */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class. This illustrates Ruby coding efficiency when looking inside classes.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing'', ''reflection'', and ''metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T17:44:02Z

Amosti: /* ''Refrences'' */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing'', ''reflection'', and ''metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''References'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T11:45:23Z

Amosti: /* ''External Links'' */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing'', ''reflection'', and ''metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html
*http://www.javaworld.com/javaworld/jw-07-2006/jw-0717-ruby.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T01:43:54Z

Amosti: /* Ruby Reflection vs. Java Reflection */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.
**In order to print out all the methods contained in a class in Java, we approached 100 lines of code. It took merely 4 lines of code in Ruby to print all private, protected, public, and singleton methods of a class.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing'', ''reflection'', and ''metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T01:37:37Z

Amosti: /* Ruby Reflection Sequences */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>
A third way methods can be invoked dynamically using reflection is with the <tt>eval</tt> method. <tt>eval</tt> provides the ability to parse and execute an arbitrary string of legal Ruby source code. The string of code can be stored as an object, and then evaluated at a later time.
<pre>
irb(main):111:0> eval_test = %q{"A third test".length}
=> "\"A third test\".length"
irb(main):112:0> eval eval_test
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing, reflection and metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T01:25:40Z

Amosti: /* Ruby Reflection Sequences */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

In addition to looking inside classes, reflection in Ruby provides the ability to dynamically call methods. An arbitrary method of some object can be called using <tt>Object#send</tt>, <tt>Method#call</tt>, and also various versions of the <tt>eval</tt> method (including <tt>class_eval</tt>, <tt>module_eval</tt>, and <tt>instance_eval</tt>).

<tt>send</tt> works on any object, and it calls the passed in method on that object. It will also find new methods added at runtime. In the below example, the <tt>length</tt> method is called on the object, which is a 14 character string.
<pre>
irb(main):105:0> "This is a test".send(:length)
=> 14
</pre>
<tt>Method</tt> objects represent a chunk of code and a context in which it executes. The <tt>Method</tt> object is created, and it can be executed whenever desired by sending it the <tt>call</tt> message:
<pre>
irb(main):106:0> test_message = "Test message".method(:length)
=> #<Method: String#length>
irb(main):107:0> test_message.call
=> 12
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing, reflection and metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T00:56:22Z

Amosti: /* Reflection in Ruby and Java */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues due to the extra overhead when determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing, reflection and metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

*Reflection API in java is also used in Database Access with SQL.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T00:43:34Z

Amosti: /* Reflection in Ruby and Java */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime. This provides for a very liberated and dynamic programming environment.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges when using Reflection is that you need to clarify what services you wish to provide at runtime, i.e. ones that you don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution, though, over-reliance on Reflection can lead to performance issues because of the extra overhead of determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.

*Reflection API in java is also used in Database Access with SQL.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing, reflection and metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links'' ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

CSC/ECE 517 Summer 2008/wiki1 3 aobk

2008-06-06T00:30:11Z

Amosti: /* Reflection in Ruby and Java */

== Reflection in Ruby and Java ==
;What is ''Reflection''?
Reflection, in the realm of Computer Science, is the process of introspection by a program. Introspection allows program entities to discover things about themselves. Through the technique of ''metaprogramming'', aspects of a program are examined from within the program itself, which enables the program to modify itself at runtime.

By looking at and inside classes and objects, much can be discovered, including the following:
* what objects are contained in a program
* the class hierarchy
* the attributes and methods of the objects contained in the program
* various method information

One of the design challenges of using Reflection is that you need to clarify what services you wish to provide at runtime that don't want to implement statically. The provision of reusable services that vary based upon the runtime environment is one of the reasons that frameworks such as Struts and JAAS are created. However, even small applications can face design issues that make a dynamic solution preferable over a static one. A word of caution though, over-reliance on Reflection can lead to performance issues because of the extra overhead of determining what class(es) need to be loaded.

=== Java Reflection Sequences ===
;''Reflection in Java''
:Java uses a '''Reflection API''' to inspect and manipulate itself. It includes the expanded ''class'' class in java.lang and the java.lang.reflect package, which represents the members of a class with ''Method'', ''Constructor'' and ''Field'' objects.Reflection can be used to obtain information about a class and its members.

Example:

*This example uses the <tt>Class.forName()</tt> method to dynamically load the named class, and then calls various methods of the ''class'' object to look up the Superclass, Interfaces, and Members of the class. The example uses ''Constructor'', ''Field'' and ''Method'' objects to obtain information about each member of the class.

<pre>
import java.lang.reflect.*;

/** A program that displays a class synopsis for the named class */

public class ShowClass {
/** The main method. Print info about the named class */
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName(args[0]);
print_class(c);
}

/** Display the modifiers, name, superclass and interfaces of a class
* or interface. Then go and list all constructors, fields, and methods. */
public static void print_class(Class c)
{
// Print modifiers, type (class or interface), name and superclass.
if (c.isInterface()) {
// The modifiers will include the "interface" keyword here...
System.out.print(Modifier.toString(c.getModifiers()) + " "+c.getName());
}
else if (c.getSuperclass() != null)
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName() +
" extends " + c.getSuperclass().getName());
else
System.out.print(Modifier.toString(c.getModifiers()) + " class " +
c.getName());

// Print interfaces or super-interfaces of the class or interface.
Class[] interfaces = c.getInterfaces();
if ((interfaces != null) && (interfaces.length > 0)) {
if (c.isInterface()) System.out.println(" extends ");
else System.out.print(" implements ");
for(int i = 0; i < interfaces.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(interfaces[i].getName());
}
}

System.out.println(" {"); // Begin class member listing.

// Now look up and display the members of the class.
System.out.println(" // Constructors");
Constructor[] constructors = c.getDeclaredConstructors();
for(int i = 0; i < constructors.length; i++) // Display constructors.
print_method_or_constructor(constructors[i]);

System.out.println(" // Fields");
Field[] fields = c.getDeclaredFields(); // Look up fields.
for(int i = 0; i < fields.length; i++) // Display them.
print_field(fields[i]);

System.out.println(" // Methods");
Method[] methods = c.getDeclaredMethods(); // Look up methods.
for(int i = 0; i < methods.length; i++) // Display them.
print_method_or_constructor(methods[i]);

System.out.println("}"); // End class member listing.
}

/** Return the name of an interface or primitive type, handling arrays. */
public static String typename(Class t) {
String brackets = "";
while(t.isArray()) {
brackets += "[]";
t = t.getComponentType();
}
return t.getName() + brackets;
}

/** Return a string version of modifiers, handling spaces nicely. */
public static String modifiers(int m) {
if (m == 0) return "";
else return Modifier.toString(m) + " ";
}

/** Print the modifiers, type, and name of a field */
public static void print_field(Field f) {
System.out.println(" " +
modifiers(f.getModifiers()) +
typename(f.getType()) + " " + f.getName() + ";");
}

/** Print the modifiers, return type, name, parameter types and exception
* type of a method or constructor. Note the use of the Member interface
* to allow this method to work with both Method and Constructor objects */
public static void print_method_or_constructor(Member member) {
Class returntype=null, parameters[], exceptions[];
if (member instanceof Method) {
Method m = (Method) member;
returntype = m.getReturnType();
parameters = m.getParameterTypes();
exceptions = m.getExceptionTypes();
} else {
Constructor c = (Constructor) member;
parameters = c.getParameterTypes();
exceptions = c.getExceptionTypes();
}

System.out.print(" " + modifiers(member.getModifiers()) +
((returntype!=null)? typename(returntype)+" " : "") +
member.getName() + "(");
for(int i = 0; i < parameters.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(parameters[i]));
}
System.out.print(")");
if (exceptions.length > 0) System.out.print(" throws ");
for(int i = 0; i < exceptions.length; i++) {
if (i > 0) System.out.print(", ");
System.out.print(typename(exceptions[i]));
}
System.out.println(";");
}
}
</pre>

This code is then compiled and run, with the following simple test class passed in:
<pre>
public class testInput {
public static void main(String[] args) {}
public int method1() {
return 0;
}
public String method2() {
return "";
}
public void method3() {}
public void method4(int num) {}
}
</pre>
The output generated is as follows:
<pre>
public class testInput extends java.lang.Object {
// Constructors
public testInput();
// Fields
// Methods
public int method1();
public java.lang.String method2();
public void method3();
public void method4(int);
public static void main(java.lang.String[]);
}
</pre>

=== Ruby Reflection Sequences ===
The Java code above, which displays constructors, methods, and other information pertinent to the ''testInput'' class, is somewhat convoluted and difficult to trace. In Ruby, the methods below can be called on a module/class to return similar information:
*<tt>''mod''.private_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.protected_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.public_instance_methods(''inc_super''=true)</tt>
*<tt>''mod''.singleton_methods(''inc_super''=true)</tt>
For example, using the <tt>Demo</tt> class below, all of the class' methods (private, protected, public, and singleton) can be easily displayed.
<pre>
irb(main):001:0> class Demo
irb(main):002:1> public
irb(main):003:1> def method1
irb(main):004:2> end
irb(main):005:1> private
irb(main):006:1> def method2
irb(main):007:2> end
irb(main):008:1> public
irb(main):009:1> def method3
irb(main):010:2> end
irb(main):011:1> protected
irb(main):012:1> def method4
irb(main):013:2> end
irb(main):014:1> def Demo.method5
irb(main):015:2> end
irb(main):016:1> public
irb(main):017:1> def method6
irb(main):018:2> end
irb(main):019:1> end
=> nil
irb(main):020:0> Demo.private_instance_methods(false)
=> ["method2"]
irb(main):021:0> Demo.protected_instance_methods(false)
=> ["method4"]
irb(main):022:0> Demo.public_instance_methods(false)
=> ["method3", "method6", "method1"]
irb(main):023:0> Demo.singleton_methods(false)
=> ["method5"]
</pre>

=== Ruby Reflection vs. Java Reflection ===

*By coding and comparing we find that Reflection in Java tends to be more verbose than Ruby code which accomplishes the same task. Also, exceptions such as <tt>NoSuchMethodError</tt> and <tt>InvocationTargetException</tt> tend to create further complications and confusion when using Java's reflection API.

*Reflection API in java is also used in Database Access with SQL.

*In Ruby, Aspect Oriented Programming(AOP) can be performed using ''aliasing, reflection and metaprogramming''. These language facilities make it much easier to perform AOP than in Java.

=== Uses of Reflection ===
Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

*Extensibility Features
An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.

*Class Browsers and Visual Development Environments
A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.

*Debuggers and Test Tools
Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

=== Drawbacks of Reflection ===
Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

*Performance Overhead
Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.

*Security Restrictions
Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.

*Exposure of Internals
Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

=== ''Refrences'' ===
#Flanagan, David. [http://books.google.com/books?id=kADTIsgeLh4C Java Examples in a Nutshell]. O'Reilly, 2004.
#Thomas, Dave. [http://books.google.com/books?id=8LXOAAAACAAJ Programming Ruby]. Raleigh: Pragmatic Bookshelf, 2004.

=== ''External Links ===
*http://phrogz.net/programmingruby/ospace.html
*http://java.sun.com/docs/books/tutorial/reflect/
*http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html