Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2b 2w49 ps

2012-11-18T05:08:28Z

Schand10:

'''Template Method Pattern - Directory of Sites'''

==Introduction==
This page provides a directory of sites that can be used as reference to learn about Template Method Pattern in [http://en.wikipedia.org/wiki/Object-oriented_design Object oriented design]

==Directory of Sites==
===1. Template method pattern (Wikipedia)===

http://en.wikipedia.org/wiki/Template_method_pattern

This is the first reference site that everyone uses to learn about an established fact. The site offers a very good introduction to template method pattern and is well organized. It also provides an example for the usage of template pattern in Java. The site also explains briefly why we need to use template pattern. It also explains the concept with the help of UML diagrams in a simple way.
====Drawbacks====
The site does not compare this pattern with other design patterns. If we need to compare we have to read through other wikis on design patterns and should understand the differences by self.

===2. Template Method (oodesign.com)===

http://www.oodesign.com/template-method-pattern.html

This is a very good site to learn about design patterns in general and provides a good explanation for Template Method Patterns also. The site is very informative and detailed. The organization of the content is very good and is done in a simple manner. The site also provides specific problems and implementations. The site also provides a brief view on the comparison between template method pattern and the most closest, strategy pattern. There is a section which summarizes the hot points to be noted while using Template Method Pattern. The site also provides multiple examples and UML diagrams which make the content easy to comprehend.

===3. Template Method Design Pattern (dofactory.com)===

http://www.dofactory.com/Patterns/PatternTemplate.aspx

The site is a very good reference when it comes to examples of using template method pattern. The description about the pattern in words is very limited. But the examples provide a very easy way to understand the pattern. The major advantage is, it gives the usage of template pattern in multiple OO languages like Java, C# and a real world example.
====Drawbacks====
1. The description does not cover all the necessary details about the pattern
2. Comparison with other patterns are not present
3. Does not justify the requirement of using template pattern

===4. Patterns I Hate #2: Template Method (Blog)===

http://tech.puredanger.com/2007/07/03/pattern-hate-template/

This is not a site to understand the template method pattern. Rather, this site is very informative in understanding the disadvantages of using template method pattern. Before referring this site, you should be aware of the template method pattern. The site provides alternatives to the use of template pattern.
====Drawbacks====
1. No reference to the actual description about template method pattern.
2. Examples are difficult to understand with the limited explanation

===5. Similarities/Differences between template method pattern and strategy pattern? (Stack overflow)===

http://stackoverflow.com/questions/10376024/is-there-similarities-between-template-method-pattern-and-strategy-pattern

This link is very informative in understanding the differences between the template pattern and the strategy pattern. The site provides several posts from many people which could be a good way to get different views about template pattern and other design patterns. It also makes use of an example to understand the differences between template design pattern and strategy pattern.

====Drawbacks====
1. Not a reference page to learn about template design pattern. It can only provide comparisons.

===6. Where should we use Template Method - pattern? (Stack Overflow)===

http://stackoverflow.com/questions/1553856/where-should-we-use-template-method-pattern

This site provides a good insight towards understanding when the Template method pattern should be used. The examples provided can give a good idea about the usage of template method pattern. This is not a site that can be used to learn template method pattern. It assumes prior knowledge about design patterns in general.

===7. Template method design patterns in Java/J2EE (Javabeat.com)===

http://www.javabeat.net/2007/08/template-method-pattern-design-patterns-in-javaj2ee/

The Site gives a crisp definition of the pattern and there after gives an example as to how one can implement the pattern Template. It supports the example with a code in java.

===8. Template Method in Java (SourceMaking.com)===

http://sourcemaking.com/design_patterns/template_method/java/2

The site describes the pattern in the form of summary points and supports the same with a code in java that merely explains the usage of the pattern.

===9. Design Patterns Uncovered: The Template Method Pattern (DZone)===

http://java.dzone.com/articles/design-patterns-template-method

The site introduces the pattern with a real world example. It subsequently gives a clear definition of the pattern. It also provides a diagrammatic representation of the pattern in the form of a UML diagram. It elaborates the on Abstract and concrete classes required to implement the pattern. It further explains when we one should use the pattern supporting it with an example. The article ends with a java code implementation for an abstract compiler class that is varyingly used for different compiler classes.

===10. Template Method Design Pattern (BlackWasp)===

http://www.blackwasp.co.uk/TemplateMethod.aspx

The site gives a brief overview of the pattern and also talks about the difference between a very similar strategy pattern and template pattern. It also provides arguments in support of the pattern and its advantages. An example of algorithms with similar steps is presented to explain the concept.

===11. Template Method Design Patterns (SourceMaking)===

http://sourcemaking.com/design_patterns/template_method

The site introduces the pattern by providing the reader with the reason as to why we need the pattern. Thereafter a discussion is presented that explains the concept of hooks and placeholders. The discussion also presents a diagrammatic representation of the real world scenario.

===12. Template method Pattern – Design Patterns in Java/J2EE (JavaBeat)===

http://www.javabeat.net/2007/08/template-method-pattern-design-patterns-in-javaj2ee/

The site provides the definition of the pattern and puts across an example of using the pattern in loading and parsing data in oracle. It also suffices the explanation with 6 other real software problems where template pattern can be employed like ‘flexible extendable generalized specialized user interfaces’, ‘ASP.net page life cycle’, ‘code generators’, ‘XML parsers’.

==Comparison Table==

The table provides the comparison between the 12 of the websites that have useful information regarding Template Method Pattern. The websites are rated on certain parameters (shown in table) with the maximum rating being (☆☆☆☆) and the minimum ( nil ). The numeric count of the site is the same as represented above.

{| class="wikitable"
|-
! Characteristic !! Site 1 !! Site 2 !! Site 3 !! Site 4 !! Site 5 !! Site 6 !! Site 7 !! Site 8 !! Site 9 !! Site 10 !! Site 11 !! Site 12
|-
| Clarity of content & fullness || ☆☆☆☆ || ☆☆☆☆ || ☆☆ || ☆ || || ☆ || ☆☆ || ☆☆ || ☆☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆
|-
| Most suitable examples(code) || ☆☆ || ☆☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆☆ || ☆☆☆ || ☆☆☆ || ☆☆ || ☆☆☆☆
|-
| Comparison with closely related patterns || || ☆☆ || || || ☆☆☆ || || || || || || ||
|-
| Structure of the represented information || ☆☆☆☆ || ☆☆☆☆ || ☆☆ || ☆☆ || ☆ || ☆ || ☆☆ || ☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆
|-
| Real World usages || || ☆☆ || ☆☆☆☆ || || || ☆☆☆ || || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆ || ☆☆☆☆
|-
| Disadvantages of the pattern || || || || ☆☆☆☆ || || || || || ☆☆☆ || ☆☆ || ||
|}

CSC/ECE 517 Fall 2012/ch2b 2w49 ps

2012-11-18T05:06:54Z

Schand10: /* Summary Table */

'''Template Method Pattern - Directory of Sites'''

==Introduction==
This page provides a directory of sites that can be used as reference to learn about Template Method Pattern in [http://en.wikipedia.org/wiki/Object-oriented_design Object oriented design]

==Directory of Sites==
===1. Template method pattern (Wikipedia)===

http://en.wikipedia.org/wiki/Template_method_pattern

This is the first reference site that everyone uses to learn about an established fact. The site offers a very good introduction to template method pattern and is well organized. It also provides an example for the usage of template pattern in Java. The site also explains briefly why we need to use template pattern. It also explains the concept with the help of UML diagrams in a simple way.
====Drawbacks====
The site does not compare this pattern with other design patterns. If we need to compare we have to read through other wikis on design patterns and should understand the differences by self.

===2. Template Method (oodesign.com)===

http://www.oodesign.com/template-method-pattern.html

This is a very good site to learn about design patterns in general and provides a good explanation for Template Method Patterns also. The site is very informative and detailed. The organization of the content is very good and is done in a simple manner. The site also provides specific problems and implementations. The site also provides a brief view on the comparison between template method pattern and the most closest, strategy pattern. There is a section which summarizes the hot points to be noted while using Template Method Pattern. The site also provides multiple examples and UML diagrams which make the content easy to comprehend.

===3. Template Method Design Pattern (dofactory.com)===

http://www.dofactory.com/Patterns/PatternTemplate.aspx

The site is a very good reference when it comes to examples of using template method pattern. The description about the pattern in words is very limited. But the examples provide a very easy way to understand the pattern. The major advantage is, it gives the usage of template pattern in multiple OO languages like Java, C# and a real world example.
====Drawbacks====
1. The description does not cover all the necessary details about the pattern
2. Comparison with other patterns are not present
3. Does not justify the requirement of using template pattern

===4. Patterns I Hate #2: Template Method (Blog)===

http://tech.puredanger.com/2007/07/03/pattern-hate-template/

This is not a site to understand the template method pattern. Rather, this site is very informative in understanding the disadvantages of using template method pattern. Before referring this site, you should be aware of the template method pattern. The site provides alternatives to the use of template pattern.
====Drawbacks====
1. No reference to the actual description about template method pattern.
2. Examples are difficult to understand with the limited explanation

===5. Similarities/Differences between template method pattern and strategy pattern? (Stack overflow)===

http://stackoverflow.com/questions/10376024/is-there-similarities-between-template-method-pattern-and-strategy-pattern

This link is very informative in understanding the differences between the template pattern and the strategy pattern. The site provides several posts from many people which could be a good way to get different views about template pattern and other design patterns. It also makes use of an example to understand the differences between template design pattern and strategy pattern.

====Drawbacks====
1. Not a reference page to learn about template design pattern. It can only provide comparisons.

===6. Where should we use Template Method - pattern? (Stack Overflow)===

http://stackoverflow.com/questions/1553856/where-should-we-use-template-method-pattern

This site provides a good insight towards understanding when the Template method pattern should be used. The examples provided can give a good idea about the usage of template method pattern. This is not a site that can be used to learn template method pattern. It assumes prior knowledge about design patterns in general.

===7. Template method design patterns in Java/J2EE (Javabeat.com)===

http://www.javabeat.net/2007/08/template-method-pattern-design-patterns-in-javaj2ee/

The Site gives a crisp definition of the pattern and there after gives an example as to how one can implement the pattern Template. It supports the example with a code in java.

===8. Template Method in Java (SourceMaking.com)===

http://sourcemaking.com/design_patterns/template_method/java/2

The site describes the pattern in the form of summary points and supports the same with a code in java that merely explains the usage of the pattern.

===9. Design Patterns Uncovered: The Template Method Pattern (DZone)===

http://java.dzone.com/articles/design-patterns-template-method

The site introduces the pattern with a real world example. It subsequently gives a clear definition of the pattern. It also provides a diagrammatic representation of the pattern in the form of a UML diagram. It elaborates the on Abstract and concrete classes required to implement the pattern. It further explains when we one should use the pattern supporting it with an example. The article ends with a java code implementation for an abstract compiler class that is varyingly used for different compiler classes.

===10. Template Method Design Pattern (BlackWasp)===

http://www.blackwasp.co.uk/TemplateMethod.aspx

The site gives a brief overview of the pattern and also talks about the difference between a very similar strategy pattern and template pattern. It also provides arguments in support of the pattern and its advantages. An example of algorithms with similar steps is presented to explain the concept.

===11. Template Method Design Patterns (SourceMaking)===

http://sourcemaking.com/design_patterns/template_method

The site introduces the pattern by providing the reader with the reason as to why we need the pattern. Thereafter a discussion is presented that explains the concept of hooks and placeholders. The discussion also presents a diagrammatic representation of the real world scenario.

===12. Template method Pattern – Design Patterns in Java/J2EE (JavaBeat)===

http://www.javabeat.net/2007/08/template-method-pattern-design-patterns-in-javaj2ee/

The site provides the definition of the pattern and puts across an example of using the pattern in loading and parsing data in oracle. It also suffices the explanation with 6 other real software problems where template pattern can be employed like ‘flexible extendable generalized specialized user interfaces’, ‘ASP.net page life cycle’, ‘code generators’, ‘XML parsers’.

==Summary Table==

The table provides the comparison between the 12 of the websites that have useful information regarding Template Method Pattern. The websites are rated on certain parameters (shown in table) with the maximum rating being (☆☆☆☆) and the minimum ( nil ). The numeric count of the site is the same as represented above.

{| class="wikitable"
|-
! Characteristic !! Site 1 !! Site 2 !! Site 3 !! Site 4 !! Site 5 !! Site 6 !! Site 7 !! Site 8 !! Site 9 !! Site 10 !! Site 11 !! Site 12
|-
| Clarity of content & fullness || ☆☆☆☆ || ☆☆☆☆ || ☆☆ || ☆ || || ☆ || ☆☆ || ☆☆ || ☆☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆
|-
| Most suitable examples(code) || ☆☆ || ☆☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆☆ || ☆☆☆ || ☆☆☆ || ☆☆ || ☆☆☆☆
|-
| Comparison with closely related patterns || || ☆☆ || || || ☆☆☆ || || || || || || ||
|-
| Structure of the represented information || ☆☆☆☆ || ☆☆☆☆ || ☆☆ || ☆☆ || ☆ || ☆ || ☆☆ || ☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆
|-
| Real World usages || || ☆☆ || ☆☆☆☆ || || || ☆☆☆ || || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆ || ☆☆☆☆
|-
| Disadvantages of the pattern || || || || ☆☆☆☆ || || || || || ☆☆☆ || ☆☆ || ||
|}

CSC/ECE 517 Fall 2012/ch2b 2w49 ps

2012-11-18T05:02:02Z

Schand10: Created page with "'''Template Method Pattern - Directory of Sites''' ==Introduction== This page provides a directory of sites that can be used as reference to learn abo..."

'''Template Method Pattern - Directory of Sites'''

==Introduction==
This page provides a directory of sites that can be used as reference to learn about Template Method Pattern in [http://en.wikipedia.org/wiki/Object-oriented_design Object oriented design]

==Directory of Sites==
===1. Template method pattern (Wikipedia)===

http://en.wikipedia.org/wiki/Template_method_pattern

This is the first reference site that everyone uses to learn about an established fact. The site offers a very good introduction to template method pattern and is well organized. It also provides an example for the usage of template pattern in Java. The site also explains briefly why we need to use template pattern. It also explains the concept with the help of UML diagrams in a simple way.
====Drawbacks====
The site does not compare this pattern with other design patterns. If we need to compare we have to read through other wikis on design patterns and should understand the differences by self.

===2. Template Method (oodesign.com)===

http://www.oodesign.com/template-method-pattern.html

This is a very good site to learn about design patterns in general and provides a good explanation for Template Method Patterns also. The site is very informative and detailed. The organization of the content is very good and is done in a simple manner. The site also provides specific problems and implementations. The site also provides a brief view on the comparison between template method pattern and the most closest, strategy pattern. There is a section which summarizes the hot points to be noted while using Template Method Pattern. The site also provides multiple examples and UML diagrams which make the content easy to comprehend.

===3. Template Method Design Pattern (dofactory.com)===

http://www.dofactory.com/Patterns/PatternTemplate.aspx

The site is a very good reference when it comes to examples of using template method pattern. The description about the pattern in words is very limited. But the examples provide a very easy way to understand the pattern. The major advantage is, it gives the usage of template pattern in multiple OO languages like Java, C# and a real world example.
====Drawbacks====
1. The description does not cover all the necessary details about the pattern
2. Comparison with other patterns are not present
3. Does not justify the requirement of using template pattern

===4. Patterns I Hate #2: Template Method (Blog)===

http://tech.puredanger.com/2007/07/03/pattern-hate-template/

This is not a site to understand the template method pattern. Rather, this site is very informative in understanding the disadvantages of using template method pattern. Before referring this site, you should be aware of the template method pattern. The site provides alternatives to the use of template pattern.
====Drawbacks====
1. No reference to the actual description about template method pattern.
2. Examples are difficult to understand with the limited explanation

===5. Similarities/Differences between template method pattern and strategy pattern? (Stack overflow)===

http://stackoverflow.com/questions/10376024/is-there-similarities-between-template-method-pattern-and-strategy-pattern

This link is very informative in understanding the differences between the template pattern and the strategy pattern. The site provides several posts from many people which could be a good way to get different views about template pattern and other design patterns. It also makes use of an example to understand the differences between template design pattern and strategy pattern.

====Drawbacks====
1. Not a reference page to learn about template design pattern. It can only provide comparisons.

===6. Where should we use Template Method - pattern? (Stack Overflow)===

http://stackoverflow.com/questions/1553856/where-should-we-use-template-method-pattern

This site provides a good insight towards understanding when the Template method pattern should be used. The examples provided can give a good idea about the usage of template method pattern. This is not a site that can be used to learn template method pattern. It assumes prior knowledge about design patterns in general.

===7. Template method design patterns in Java/J2EE (Javabeat.com)===

http://www.javabeat.net/2007/08/template-method-pattern-design-patterns-in-javaj2ee/

The Site gives a crisp definition of the pattern and there after gives an example as to how one can implement the pattern Template. It supports the example with a code in java.

===8. Template Method in Java (SourceMaking.com)===

http://sourcemaking.com/design_patterns/template_method/java/2

The site describes the pattern in the form of summary points and supports the same with a code in java that merely explains the usage of the pattern.

===9. Design Patterns Uncovered: The Template Method Pattern (DZone)===

http://java.dzone.com/articles/design-patterns-template-method

The site introduces the pattern with a real world example. It subsequently gives a clear definition of the pattern. It also provides a diagrammatic representation of the pattern in the form of a UML diagram. It elaborates the on Abstract and concrete classes required to implement the pattern. It further explains when we one should use the pattern supporting it with an example. The article ends with a java code implementation for an abstract compiler class that is varyingly used for different compiler classes.

===10. Template Method Design Pattern (BlackWasp)===

http://www.blackwasp.co.uk/TemplateMethod.aspx

The site gives a brief overview of the pattern and also talks about the difference between a very similar strategy pattern and template pattern. It also provides arguments in support of the pattern and its advantages. An example of algorithms with similar steps is presented to explain the concept.

===11. Template Method Design Patterns (SourceMaking)===

http://sourcemaking.com/design_patterns/template_method

The site introduces the pattern by providing the reader with the reason as to why we need the pattern. Thereafter a discussion is presented that explains the concept of hooks and placeholders. The discussion also presents a diagrammatic representation of the real world scenario.

===12. Template method Pattern – Design Patterns in Java/J2EE (JavaBeat)===

http://www.javabeat.net/2007/08/template-method-pattern-design-patterns-in-javaj2ee/

The site provides the definition of the pattern and puts across an example of using the pattern in loading and parsing data in oracle. It also suffices the explanation with 6 other real software problems where template pattern can be employed like ‘flexible extendable generalized specialized user interfaces’, ‘ASP.net page life cycle’, ‘code generators’, ‘XML parsers’.

==Summary Table==

{| class="wikitable"
|-
! Characteristic !! Site 1 !! Site 2 !! Site 3 !! Site 4 !! Site 5 !! Site 6 !! Site 7 !! Site 8 !! Site 9 !! Site 10 !! Site 11 !! Site 12
|-
| Clarity of content & fullness || ☆☆☆☆ || ☆☆☆☆ || ☆☆ || ☆ || || ☆ || ☆☆ || ☆☆ || ☆☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆
|-
| Most suitable examples(code) || ☆☆ || ☆☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆☆ || ☆☆☆ || ☆☆☆ || ☆☆ || ☆☆☆☆
|-
| Comparison with closely related patterns || || ☆☆ || || || ☆☆☆ || || || || || || ||
|-
| Structure of the represented information || ☆☆☆☆ || ☆☆☆☆ || ☆☆ || ☆☆ || ☆ || ☆ || ☆☆ || ☆☆ || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆
|-
| Real World usages || || ☆☆ || ☆☆☆☆ || || || ☆☆☆ || || ☆☆☆ || ☆☆ || ☆☆☆ || ☆☆☆ || ☆☆☆☆
|-
| Disadvantages of the pattern || || || || ☆☆☆☆ || || || || || ☆☆☆ || ☆☆ || ||
|}

CSC/ECE 517 Fall 2012

2012-11-18T03:42:59Z

Schand10:

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

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w58 am]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w52 an]]
*[[CSC/ECE_517_Fall_2012/ch1b 1w38 nm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w60 ac]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w62 rb]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w29 st]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w3_sm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w30 an]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w17 pt]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w31 up]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w9 ms]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w19 is]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w26 aj]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w16 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w8 vp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w18 as]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w3 jm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w23 sr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w11_aa]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w15 rr]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w33 pv]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w20_aa]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w14_bb]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w21_ap]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w13_sm]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w4_sa]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w25_nr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w12_sv]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w7_ma]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w6_ar]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w32_mk]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w10_rc]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w70_sm]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w67_sk]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w40_sn]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w22_sk]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w-1w65_am]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w59_bc]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w60_ns]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w69_as]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w39_ka]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w36_av]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w37_ms]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w43_iv]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w53_iv]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w63_sp]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w49_ps]]

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T01:25:11Z

Schand10: /* Creating an object from the class */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a [http://en.wikipedia.org/wiki/Application_software software application].

Objects consist of data [http://en.wikipedia.org/wiki/Variable_%28computer_science%29 variables] and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the [http://en.wikipedia.org/wiki/Keyword_%28computer_programming%29 keyword] ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

Another Example:

class Person
attr_reader :name, :age
def initialize(name, age)
@name, @age = name, age
end
end

# create 3 objects of class Person
p1 = Person.new("Bob", 33),
p2 = Person.new("Chris", 16),
p3 = Person.new("Ash", 23)

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-[http://en.wikipedia.org/wiki/Parameter_%28computer_programming%29#Parameters_and_arguments argument] calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:54:45Z

Schand10: /* Poetry Mode */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a [http://en.wikipedia.org/wiki/Application_software software application].

Objects consist of data [http://en.wikipedia.org/wiki/Variable_%28computer_science%29 variables] and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the [http://en.wikipedia.org/wiki/Keyword_%28computer_programming%29 keyword] ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-[http://en.wikipedia.org/wiki/Parameter_%28computer_programming%29#Parameters_and_arguments argument] calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:51:00Z

Schand10: /* Destructive Methods */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a [http://en.wikipedia.org/wiki/Application_software software application].

Objects consist of data [http://en.wikipedia.org/wiki/Variable_%28computer_science%29 variables] and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the [http://en.wikipedia.org/wiki/Keyword_%28computer_programming%29 keyword] ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:48:52Z

Schand10: /* Defining a Ruby class */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a [http://en.wikipedia.org/wiki/Application_software software application].

Objects consist of data [http://en.wikipedia.org/wiki/Variable_%28computer_science%29 variables] and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the [http://en.wikipedia.org/wiki/Keyword_%28computer_programming%29 keyword] ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:46:25Z

Schand10: /* What is an Object? */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a [http://en.wikipedia.org/wiki/Application_software software application].

Objects consist of data [http://en.wikipedia.org/wiki/Variable_%28computer_science%29 variables] and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:44:33Z

Schand10: /* What is an Object? */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a [http://en.wikipedia.org/wiki/Application_software software application].

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:43:11Z

Schand10: /* Introduction */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a [http://en.wikipedia.org/wiki/Method_%28computer_programming%29 method] call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.

==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:29:50Z

Schand10: /* References */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf Section 6, 6.1, 13, 13.3
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:22:16Z

Schand10: /* Every operation is a method call */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

Note: a.b does NOT mean that "b" is an instance variable of "a" OR "a" is some kind of data structure that has "b" as a member.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:16:38Z

Schand10: /* Further Reading */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html
#http://www.mentby.com/david-a-black/are-methods-objects.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:14:35Z

Schand10: /* References */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html
#http://www.zenspider.com/Languages/Ruby/QuickRef.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:13:25Z

Schand10: /* References */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby.activeventure.com/programmingruby/book/tut_classes.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:12:18Z

Schand10: /* Further Reading */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html
#http://ruby.activeventure.com/programmingruby/book/index.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:11:38Z

Schand10: /* References */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html
#http://ruby.activeventure.com/programmingruby/book/tut_methods.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:10:13Z

Schand10: /* References */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html
#http://strugglingwithruby.blogspot.com/2009/01/ruby-methods-part-4-calling-methods.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:09:04Z

Schand10: /* References */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-classes.html

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:08:17Z

Schand10: /* Further Reading */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/
#http://strugglingwithruby.blogspot.com/2008/12/ruby-methods-part-1-basics.html

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:07:16Z

Schand10: /* Further Reading */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/
#http://eli.thegreenplace.net/2006/04/18/understanding-ruby-blocks-procs-and-methods/

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-11T00:02:51Z

Schand10: /* Everything is an Object */

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] make use of different entities like objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent, flexible and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used in an application. They serve as building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object so as to perform certain tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object about the methods it could respond to by calling a member function on the object.

Example:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows a more simplified approach which is influenced by the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language. It involves giving methods and [http://en.wikipedia.org/wiki/Instance_variable instance variables] to all of its types. This eases one’s use of Ruby. Since Ruby is made up of objects, the rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what functions they will perform. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate directly on the data. Rather than operating from outside the object; the objects have some understanding of how to operate on themselves. Messages are passed to an object, and those messages will generally elicit some kind of an action or meaningful reply depending on whether the object responds to that method. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify the original copy of an object (in-place) and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object (modified in-place), reflecting the results of the action (capitalizing a string, sorting an array, and so on). Each method has a destructive as well as a non-destructive version. The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, a new copy is created and a new object is obtained. If you call the destructive version (with ‘!’), you operate in-place on the same object to which the message is sent and the object is destructively modified.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses. It is used to simplify the method calls. Ruby prefers convention over configuration.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. The entire Ruby code is made up of only objects and method calls. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-03T21:16:15Z

Schand10:

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] divide the world between objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used as the building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object to perform tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object, which all methods it responds to.

Examples:

It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows the influence of the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language by giving methods and instance variables to all of its types. This eases one’s use of Ruby, since rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what their function will be. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate on the data directly from outside the object; rather the objects have some understanding of how to operate on themselves. We pass messages to an object, and those messages will generally elicit some kind of an action or meaningful reply. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify an object in-place and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, you get a new object. If you call the destructive version (with ‘!’), you operate in-place on the same object to which you sent the message.
Example:

y = y + [“foo”, :bar]
This will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However,
y << [6,7]
will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-03T21:00:57Z

Schand10:

'''SaaS - 3.2, 3.3 - Ruby Objects and Methods'''

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] divide the world between objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used as the building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object to perform tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object, which all methods it responds to.
Examples:

1.It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

2.Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows the influence of the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language by giving methods and instance variables to all of its types. This eases one’s use of Ruby, since rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what their function will be. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate on the data directly from outside the object; rather the objects have some understanding of how to operate on themselves. We pass messages to an object, and those messages will generally elicit some kind of an action or meaningful reply. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify an object in-place and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, you get a new object. If you call the destructive version (with ‘!’), you operate in-place on the same object to which you sent the message.
Example:

y = y + [“foo”, :bar]

The above example will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However, y << [6,7] will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/

CSC/ECE 517 Fall 2012/ch1b 1w55 ms

2012-10-03T20:57:46Z

Schand10: Created page with "==Introduction== [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]..."

==Introduction==
[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is purely an [http://en.wikipedia.org/wiki/Object-oriented_language object-oriented language]. In Ruby, everything is an [http://en.wikipedia.org/wiki/Object_%28computer_science%29 object] and every operation is a method call on some object. In contrast, hybrid languages such as [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java Java] divide the world between objects and [http://en.wikipedia.org/wiki/Primitive_type primitive types]. The hybrid approach yields better performance, but the pure object-oriented approach is more consistent and simpler to use.
==Objects In Ruby==
===What is an Object?===
An object is a self-contained piece of functionality that can be easily used, and re-used as the building blocks for a software application.

Objects consist of data variables and functions (called methods) that can be accessed and called on the object to perform tasks. These are collectively referred to as members.

===Everything is an Object===
Just about everything in Ruby, from numbers and strings to arrays is an object.
In Ruby, we can ask any object, which all methods it responds to.
Examples:

1.It considers even an integer as an object.
57.methods
It returns the entire list of methods that the “object” 57 responds to.

2.Ruby considers “nil” as an object too.
nil.respond_to?(:to_s)
It returns ‘true’ or ‘false’ depending on whether ‘nil’ responds to the method ‘to_s’.
(It does respond to the method and so returns ‘true’.)

In many languages, numbers and other primitive types are not objects. Ruby follows the influence of the [http://en.wikipedia.org/wiki/Smalltalk Smalltalk] language by giving methods and instance variables to all of its types. This eases one’s use of Ruby, since rules applying to objects apply to all of Ruby.

===Creation of Objects===
Before understanding how we create objects, we define what is a [http://en.wikipedia.org/wiki/Class_in_object-oriented_programming Class].

====What is a Class?====
A Class defines a type of data structure. It defines the various methods and member variables used by the object and what their function will be. It is a way of defining common behavior for all of the objects that are of that class type. An object is nothing but an [http://en.wikipedia.org/wiki/Instance_%28computer_science%29 instance] of a class.

====Defining a Ruby class====
For defining Classes, we use the keyword ‘class’ followed by the keyword ‘end’ and the class must be given a name by which it can be referenced. This name being a constant must begin with a capital letter.
We can illustrate this using an example:

class Student
def initialize ()
end
def test_method
puts "The class is working"
end
end

====Creating an object from the class====
An object can be created from a class using the ‘new’ method. For example, to create an instance of a Student class we perform the following:

student = Student.new()

This creates a Student object named ‘student’.
Upon the created object we can call the method ‘test_method’ by using the following:

student.test_method
The class is working

==Methods==
===What is a Method?===
In Object-Oriented Programming, we do not operate on the data directly from outside the object; rather the objects have some understanding of how to operate on themselves. We pass messages to an object, and those messages will generally elicit some kind of an action or meaningful reply. The tasks we are allowed to ask an object to perform (or equivalently, the messages it understands) are that object's methods.

===Every operation is a method call===
In Ruby, we invoke a method on an object using a dot (.) notation, just as in C++ or Java. The object on which the method performs the action is placed on the left side of the dot.
Examples:

“abcdef”.length
Output: 6

Here the ‘length’ method is called upon the object “abcdef”.
Basically, everything in the language is syntactic sugar for doing a method call. So the above example implies the following:

“abcdef”.send(:length)

‘send’ is a method that is defined by default on every object in Ruby. Here the method ‘length’ is sent to the object “abcdef”, considering that the object “abcdef” will respond to the method ‘length’.
More Examples:

1 + 2 => 1.send(:+ , 2)
my_array[4] => my_array.send(:[], 4)
my_array[3] = “foo” => my_array.send(:[]=, 3, “foo”)
my_func(z) => self.send(:my_func, z)

In short, a.b means: call method ‘b’ on object ‘a’. So ‘a’ is the receiver to which you send the method call, assuming ‘a’ will respond to the method ‘b’.

===Destructive Methods===
Ruby methods that modify an object in-place and end in an exclamation mark are known as destructive methods. By convention, the bang(!) labels a method as dangerous.

The methods usually, perform an action and return a freshly minted object, reflecting the results of the action (capitalizing a string, sorting an array, and so on). The destructive versions of the same methods perform the action, but they do so in place: Instead of creating a new object, they transform the original object.

Examples of such pairs of methods include sort/sort! for arrays, upcase/upcase! for strings, and reverse/reverse! for strings and arrays. In each case, if you call the non-destructive version of the method on the object, you get a new object. If you call the destructive version (with ‘!’), you operate in-place on the same object to which you sent the message.
Example:

y = y + [“foo”, :bar]

The above example will create a new object which is a concatenation of ‘y’ and the [“foo”, :bar] array.
However, y << [6,7] will destructively modify the receiver ‘y’ and ‘y’ will become the new array [6,7].

===Poetry Mode===
The parentheses in method calls and hashes are always optional, not just for zero-argument calls. “Poetry mode in Ruby" is a bunch of method calls with no parentheses.
Example:

a.should be >= 7
=> a.should(be() >= 7)
=> a.should(be.send(:>=, 7))

Similarly parentheses in Hashes are also optional when hash is the last argument in the method call.
Example:

link_to “Edit”, :controller => ‘students’, :action => ‘edit’
=> link_to(“Edit”, {:controller => ‘students’, :action => ‘edit’})

But in case there are multiple hashes then it is always advisable to put parentheses defensively.

==Conclusion==
Thus we can conclude that objects and its methods provide the foundation on which object-oriented programming is based. Ruby being a pure object oriented language (everything is an object and every operation is a method call), has methods inherent to its nature. Ruby methods provide a way to organize code and promote re-use while defining the behavior of ruby objects belonging to a specific type.

==References==

#http://www.youtube.com/watch?v=iWhGWPOpkbU
#http://www.ipa.go.jp/osc/english/ruby/Ruby_final_draft_enu_20100825.pdf
#http://en.wikibooks.org/wiki/Ruby_Programming/Introduction_to_objects
#http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls#Methods
#http://www.rubyist.net/~slagell/ruby/methods.html
#http://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming#What_is_an_Object.3F
#http://www.techotopia.com/index.php/Ruby_Methods
#http://rubylearning.com/satishtalim/tutorial.html
#http://ruby-doc.org/docs/ProgrammingRuby/

==Further Reading==

#http://rubymonk.com/
#http://www.ruby-lang.org/en/documentation/quickstart
#http://www.ruby-doc.org/downloads/
#http://pragprog.com/titles/ruby3/programming-ruby-1-9
#http://oreilly.com/catalog/9780596516178/

CSC/ECE 517 Fall 2012

2012-10-03T19:39:53Z

Schand10:

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

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]

User:Schand10

2012-10-03T19:32:09Z

Schand10: Created page with "This is a sample page"

This is a sample page