Object Oriented Reuse
←Older revision | Revision as of 05:49, 24 September 2022 | ||
Line 16: | Line 16: | ||
- | === Object Oriented Reuse === | + | === [[SuperVsInner|Object Oriented Reuse]] === |
{{:SuperVsInner}} | {{:SuperVsInner}} |
Object Oriented Reuse
←Older revision | Revision as of 05:49, 24 September 2022 | ||
Line 16: | Line 16: | ||
- | === Object Oriented Reuse === | + | === [[SuperVsInner|Object Oriented Reuse]] === |
{{:SuperVsInner}} | {{:SuperVsInner}} |
Revolutionary view
←Older revision | Revision as of 07:34, 24 February 2010 | ||
Line 14: | Line 14: | ||
Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. | ||
+ | |||
+ | |||
+ | === Object Oriented Reuse === | ||
+ | |||
+ | {{:SuperVsInner}} | ||
=== History === | === History === |
Revolutionary view
←Older revision | Revision as of 08:40, 7 February 2010 | ||
Line 11: | Line 11: | ||
* In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type | * In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type | ||
- | The above characteristic of [[OOP]] leads to an interesting conclussion: [[OOP]] needs [http://projectfortress.sun.com/Projects/Community/blog/ObjectOrientedTailRecursion tail | + | The above characteristic of [[OOP]] leads to an interesting conclussion: [[OOP]] needs [http://projectfortress.sun.com/Projects/Community/blog/ObjectOrientedTailRecursion tail calls]! |
Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. |
←Older revision | Revision as of 08:37, 7 February 2010 | ||
Line 10: | Line 10: | ||
* In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only by calling their methods (sending them messages) | * In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only by calling their methods (sending them messages) | ||
* In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type | * In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type | ||
+ | |||
+ | The above characteristic of [[OOP]] leads to an interesting conclussion: [[OOP]] needs [http://projectfortress.sun.com/Projects/Community/blog/ObjectOrientedTailRecursion tail recursion]! | ||
Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. |
Revolutionary view
←Older revision | Revision as of 16:48, 28 November 2009 | ||
Line 5: | Line 5: | ||
Let me point you to [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf an essay] explaining [[OOP]] in completely revolutionary view. I especially like statements like: | Let me point you to [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf an essay] explaining [[OOP]] in completely revolutionary view. I especially like statements like: | ||
* ''Typical object oriented program relies on functions more than many functional programs.'' | * ''Typical object oriented program relies on functions more than many functional programs.'' | ||
- | * ''λ-calculus was the first [[OOP]] language'' | + | * ''[[λ-calculus]] was the first [[OOP]] language'' |
Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: | Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: |
Revolutionary view
←Older revision | Revision as of 06:01, 4 November 2009 | ||
Line 8: | Line 8: | ||
Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: | Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: | ||
- | * In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only calling their methods (sending them messages) | + | * In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only by calling their methods (sending them messages) |
* In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type | * In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type | ||
History
←Older revision | Revision as of 08:23, 3 November 2009 | ||
Line 17: | Line 17: | ||
[[OOP]] is no longer what it used to be. Somehow the original great visions diluted and instead we have ''class''/''object''/''inheritance'' as present in [[Java]] and other [[OOP]] languages of these days. The daily experience we have with these languages is so strong, so defining that we sometimes tend to forget that the roots of [[OOP]] used to be driven by visions and not technical concepts. | [[OOP]] is no longer what it used to be. Somehow the original great visions diluted and instead we have ''class''/''object''/''inheritance'' as present in [[Java]] and other [[OOP]] languages of these days. The daily experience we have with these languages is so strong, so defining that we sometimes tend to forget that the roots of [[OOP]] used to be driven by visions and not technical concepts. | ||
- | I was reminded about that recently when I read [http://www.artima.com/articles/dci_vision.html | + | I was reminded about that recently when I read [[DCI]] introduction [http://www.artima.com/articles/dci_vision.html paper] at artima website. Just few quotes: |
:''Object oriented programming grew out as vision of the computer'' | :''Object oriented programming grew out as vision of the computer'' |
Revolutionary view
←Older revision | Revision as of 08:22, 3 November 2009 | ||
Line 9: | Line 9: | ||
Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: | Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: | ||
* In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only calling their methods (sending them messages) | * In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only calling their methods (sending them messages) | ||
- | * In functional world (when using algebraic types) the person that defines a type can | + | * In functional world (when using algebraic types) the person that defines a type can inspect internals of all instances of the same type |
Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. |
Revolutionary view
←Older revision | Revision as of 08:16, 3 November 2009 | ||
Line 11: | Line 11: | ||
* In functional world (when using algebraic types) the person that defines a type can inspects and rely on internals of all instances of the same type | * In functional world (when using algebraic types) the person that defines a type can inspects and rely on internals of all instances of the same type | ||
- | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [Chapter 18|Extensible Visitor Pattern Case Study]. | + | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [[Chapter 18|Extensible Visitor Pattern Case Study]]. |
=== History === | === History === |
←Older revision | Revision as of 08:02, 3 November 2009 | ||
Line 1: | Line 1: | ||
This is my personal take on [[OOP]]. In case you are searching for objective view, then rather see official [[wikipedia::Object_oriented_programming|wikipedia's explanation]]. | This is my personal take on [[OOP]]. In case you are searching for objective view, then rather see official [[wikipedia::Object_oriented_programming|wikipedia's explanation]]. | ||
+ | |||
+ | === Revolutionary view === | ||
+ | |||
+ | Let me point you to [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf an essay] explaining [[OOP]] in completely revolutionary view. I especially like statements like: | ||
+ | * ''Typical object oriented program relies on functions more than many functional programs.'' | ||
+ | * ''λ-calculus was the first [[OOP]] language'' | ||
+ | |||
+ | Excellent explanation of the differences between [[OOP]] approach and the ''functional'' one can be summarized into: | ||
+ | * In classical [[OOP]] one only knows own identity. Identity (and implementation) of others can be inspected only calling their methods (sending them messages) | ||
+ | * In functional world (when using algebraic types) the person that defines a type can inspects and rely on internals of all instances of the same type | ||
+ | |||
+ | Last but not least the [http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf essay] mentions the [[expression problem]] which I also analysed in [[TheAPIBook]]'s chapter 18: [Chapter 18|Extensible Visitor Pattern Case Study]. | ||
=== History === | === History === |