CSC/ECE 517 Fall 2012/ch1b 1w53 kc - Revision history

Hpkancha at 05:04, 28 September 2012

2012-09-28T05:04:29Z

← Older revision		Revision as of 05:04, 28 September 2012
Line 92:		Line 92:

	===Defining class level methods dynamically with closures===		===Defining class level methods dynamically with closures===
	Here a class level method is defined which closes over some of the attributes in its context (in this case the method color is able to access the variable color_name as a closure). In Ruby, we’re using send to call define_method. This is a trick (hack) in ruby that allows us to call private methods without self being the implicit receiver. define_method takes a name for the new method and a block which describes the body of the method. In ruby, this block is a closure which means we have access to the scope at the time of the method definition. In Javascript example, Javascript functions are closures. This means we get the ability to capture the scope at the time of definition for free. The ubiquity of closures in Javascript is extremely powerful and, as we have seen so far, makes metaprogramming very easy.		Here a class level method is defined which closes over some of the attributes in its context (in this case the method color is able to access the variable color_name as a closure). In Ruby, we’re using send to call define_method. This is a trick (hack) in ruby that allows us to call private methods without self being the implicit receiver. define_method takes a name for the new method and a block which describes the body of the method. In ruby, this block is a [http://en.wikipedia.org/wiki/Closure_%28computer_science%29 closure] which means we have access to the scope at the time of the method definition. In Javascript example, Javascript functions are closures. This means we get the ability to capture the scope at the time of definition for free. The ubiquity of closures in Javascript is extremely powerful and, as we have seen so far, makes metaprogramming very easy.

	====Ruby====		====Ruby====

Hpkancha at 05:01, 28 September 2012

2012-09-28T05:01:20Z

← Older revision		Revision as of 05:01, 28 September 2012
Line 172:		Line 172:
	Books/Articles:		Books/Articles:
	#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846		#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
	#~~Madsen~~, O.L.~~; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II~~. ~~Software Track~~, ~~Proceedings of the Twenty-First Annual Hawaii International Conference on~~ , ~~vol.2, no.~~, pp.~~406-415, 5~~-~~8 Jan 1988~~, ~~http://ieeexplore~~.~~ieee~~.~~org.www.lib.ncsu.edu~~:~~2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538~~		#Tratt, L. 2009. Dynamically typed languages, Advances in Computers, 77, pp. 149-184
			#Perrotta, P. 2010. Metaprogramming Ruby: Program Like the Ruby Pros

Hpkancha at 04:55, 28 September 2012

2012-09-28T04:55:25Z

← Older revision		Revision as of 04:55, 28 September 2012
Line 158:		Line 158:
	==References==		==References==
	Websites:		Websites:
	#~~Metaprogramming,~~ http://en.wikipedia.org/wiki/Metaprogramming		#http://en.wikipedia.org/wiki/Metaprogramming
	#~~Dynamic Programming Languages,~~ http://en.wikipedia.org/wiki/Dynamic_programming_language		#http://en.wikipedia.org/wiki/Dynamic_programming_language
	#~~Application Programming Interfaces (API's),~~ http://en.wikipedia.org/wiki/Application_programming_interface		#http://en.wikipedia.org/wiki/Application_programming_interface
	#http://www.linuxjournal.com/article/9604		#http://www.linuxjournal.com/article/9604
	#http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html		#http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html
Line 171:		Line 171:

	Books/Articles:		Books/Articles:
	*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846		#Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
	*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538		#Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

Hpkancha at 04:54, 28 September 2012

2012-09-28T04:54:33Z

Hpkancha at 04:52, 28 September 2012

2012-09-28T04:52:16Z

← Older revision		Revision as of 04:52, 28 September 2012
Line 144:		Line 144:

	===Advantages===		===Advantages===
	Using metaprogramming, you can create more expressive [http://en.wikipedia.org/wiki/Application_programming_interface APIs] (for example ActiveRecord uses metaprogramming to define accessor methods based on a table's column names, so you can write things like person.age instead of something like person.read_attribute("age"), where person is an active record object and the people table has a column called age) and you can accomplish some things with significantly less code than you otherwise would.		* Using metaprogramming, you can create more expressive [http://en.wikipedia.org/wiki/Application_programming_interface APIs] (for example ActiveRecord uses metaprogramming to define accessor methods based on a table's column names, so you can write things like person.age instead of something like person.read_attribute("age"), where person is an active record object and the people table has a column called age) and you can accomplish some things with significantly less code than you otherwise would.

	Performance: Meta-programs represent data to be processed in terms of the low level data structures used by the script interpreter to represent the scripting language itself. Therefore, instead of being processed by an interpreted script manipulating script-level data structures, the data is processed by the compiled code of the language interpreter manipulating low level data structures directly. This removes the levels of indirection that slow down the execution of scripts, and so results in significant performance improvements.		* Performance: Meta-programs represent data to be processed in terms of the low level data structures used by the script interpreter to represent the scripting language itself. Therefore, instead of being processed by an interpreted script manipulating script-level data structures, the data is processed by the compiled code of the language interpreter manipulating low level data structures directly. This removes the levels of indirection that slow down the execution of scripts, and so results in significant performance improvements.

	===Disadvanatges===		===Disadvanatges===
	Metaprogramming code can be very difficult to read and understand: that is because the metaprogramming code will not necessarily express what the code it is creating is about, but only how it is creating that code. As such the code it is creating can be invisible to you as a reader of the source code - the created code will only start to exist at runtime. One would therefore expect that programmers would try especially hard when they metaprogram to make that particular kind of code expressive and easy to understand.		* Metaprogramming code can be very difficult to read and understand: that is because the metaprogramming code will not necessarily express what the code it is creating is about, but only how it is creating that code. As such the code it is creating can be invisible to you as a reader of the source code - the created code will only start to exist at runtime. One would therefore expect that programmers would try especially hard when they metaprogram to make that particular kind of code expressive and easy to understand.

	Another consequence of the fact that the code produced by metaprogramming is not necessarily visible, is that debugging becomes more difficult: when analyzing problems you’ll not only be unsure how the programm works, but in addition, you won’t even be sure how the code that is executed looks like - since it is only generated at runtime.		* Another consequence of the fact that the code produced by metaprogramming is not necessarily visible, is that debugging becomes more difficult: when analyzing problems you’ll not only be unsure how the programm works, but in addition, you won’t even be sure how the code that is executed looks like - since it is only generated at runtime.

	==Conclusion==		==Conclusion==

Hpkancha at 04:48, 28 September 2012

2012-09-28T04:48:52Z

← Older revision		Revision as of 04:48, 28 September 2012
Line 154:		Line 154:

	==Conclusion==		==Conclusion==
	Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. ~~Allowing for these types of behavior comes at a price. The price is~~ the ~~potential for poor performance since the code~~ is ~~runtime optimized~~. ~~Another downfall is that rapid development is great but the flexibility allowed between type conversions means that there is a higher probability for runtime errors~~. ~~While understanding these limitation and accepting the risks~~, ~~these languages~~ can be ~~very powerful specifically in the area of Metaprogramming.~~		Dynamic languages are increasingly recognized for playing a major role in software development, specifically for quick prototyping because of the forgiveness of the languages letting requirements evolve. These languages are historically looked at as scripting languages that are inexpensive and not scalable. Once you're familiar with the techniques, metaprogramming is not as complicated as it might sound initially. Metaprogramming allows you to automate error-prone or repetitive programming tasks. You can use it to pre-generate data tables, to generate boilerplate code automatically that can't be abstracted into a function, or even to test your ingenuity on writing self-replicating code.

	~~==What’s Next?==~~
	~~In the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2010/ch4_4h next article for which the link does not exist yet]~~, ~~we will look at [http://en.wikipedia.org/wiki/Static_analysis static~~-~~analysis] tools for Ruby~~.

	==References==		==References==
	Websites:		Websites:
	*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming		*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
	*c2.com Wiki: Metaprogramming article, http://c2.com/cgi/wiki?MetaProgramming
	*Code generation Vs Metaprogramming, http://www.qcodo.com/wiki/article/background/metaprogramming
	*Solenoid, The first metaprogramming framework for [http://exist-db.org eXist-db], http://solenoid.schematronic.org
	*The Art of Enterprise Metaprogramming, http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
	*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language		*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
	*Eclipse.org, Dynamic Languages Toolkit, http://www.eclipse.org/dltk/
	*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface		*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
			*http://www.linuxjournal.com/article/9604
			*http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html
			*http://tratt.net/laurie/research/publications/html/tratt__dynamically_typed_languages/
			*http://www.sitepoint.com/typing-versus-dynamic-typing/
			*http://www.bias2build.com/thesis/ruby_v_js_MP.html
			*http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/
			*http://www.ibm.com/developerworks/linux/library/l-pymeta/index.html

	Books/Articles:		Books/Articles:
	*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846		*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
	*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538		*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538

Hpkancha at 04:40, 28 September 2012

2012-09-28T04:40:22Z

← Older revision		Revision as of 04:40, 28 September 2012
Line 140:		Line 140:

	Some other traits of some common dynamic languages worth mentioning are: the use of method_missing, [http://en.wikipedia.org/wiki/Introspection introspection], [http://en.wikipedia.org/wiki/Lazy_loading lazy loading], [http://en.wikipedia.org/wiki/Declarative_programming declarative code], extensible type system, and method aliasing.		Some other traits of some common dynamic languages worth mentioning are: the use of method_missing, [http://en.wikipedia.org/wiki/Introspection introspection], [http://en.wikipedia.org/wiki/Lazy_loading lazy loading], [http://en.wikipedia.org/wiki/Declarative_programming declarative code], extensible type system, and method aliasing.

			==Advantages & Disadvantages==

			===Advantages===
			Using metaprogramming, you can create more expressive [http://en.wikipedia.org/wiki/Application_programming_interface APIs] (for example ActiveRecord uses metaprogramming to define accessor methods based on a table's column names, so you can write things like person.age instead of something like person.read_attribute("age"), where person is an active record object and the people table has a column called age) and you can accomplish some things with significantly less code than you otherwise would.

			Performance: Meta-programs represent data to be processed in terms of the low level data structures used by the script interpreter to represent the scripting language itself. Therefore, instead of being processed by an interpreted script manipulating script-level data structures, the data is processed by the compiled code of the language interpreter manipulating low level data structures directly. This removes the levels of indirection that slow down the execution of scripts, and so results in significant performance improvements.

			===Disadvanatges===
			Metaprogramming code can be very difficult to read and understand: that is because the metaprogramming code will not necessarily express what the code it is creating is about, but only how it is creating that code. As such the code it is creating can be invisible to you as a reader of the source code - the created code will only start to exist at runtime. One would therefore expect that programmers would try especially hard when they metaprogram to make that particular kind of code expressive and easy to understand.

			Another consequence of the fact that the code produced by metaprogramming is not necessarily visible, is that debugging becomes more difficult: when analyzing problems you’ll not only be unsure how the programm works, but in addition, you won’t even be sure how the code that is executed looks like - since it is only generated at runtime.

	==Conclusion==		==Conclusion==

Hpkancha at 02:49, 28 September 2012

2012-09-28T02:49:22Z

@@ Line 77: / Line 77: @@
 ===Invoking a method dynamically===
-The next thing we’ll look at is calling methods dynamically. The ability to call a method with a name given to us at runtime is a powerful tool in [http://en.wikipedia.org/wiki/Domain-specific_language DSL] creation and metaprogramming. Here’s the code.
+The next thing we’ll look at is calling methods dynamically. The ability to call a method with a name given to us at runtime is a powerful tool in [http://en.wikipedia.org/wiki/Domain-specific_language DSL] creation and metaprogramming. Here’s the code. In case of Ruby, we supply the method name as a string and invoke it.
 ====Ruby====
    drew.send(:battle_cry)
    # => Drew says zing!!!
 ====JavaScript====
    drew['battleCry']();
    // => Drew says zing!!!
 ====Python====
    drew.__getattribute__('battle_cry')()
    # => Drew says zing!!!
 ==Putting it all together==

Hpkancha at 02:39, 28 September 2012

2012-09-28T02:39:25Z

← Older revision		Revision as of 02:39, 28 September 2012
Line 75:		Line 75:
	adam.battle_cry()		adam.battle_cry()
	# => Adam says zing!!!		# => Adam says zing!!!


	===Invoking a method dynamically===		===Invoking a method dynamically===
	The next thing we’ll look at is calling methods dynamically. The ability to call a method with a name given to us at runtime is a powerful tool in [http://en.wikipedia.org/wiki/Domain-specific_language DSL] creation and metaprogramming. Here’s the code.		The next thing we’ll look at is calling methods dynamically. The ability to call a method with a name given to us at runtime is a powerful tool in [http://en.wikipedia.org/wiki/Domain-specific_language DSL] creation and metaprogramming. Here’s the code.

	====Ruby====		====Ruby====
	drew.send(:battle_cry)		drew.send(:battle_cry)
	# => Drew says zing!!!		# => Drew says zing!!!

	====JavaScript====		====JavaScript====
	drew['battleCry']();		drew['battleCry']();
	// => Drew says zing!!!		// => Drew says zing!!!

	====Python====		====Python====
	drew.__getattribute__('battle_cry')()		drew.__getattribute__('battle_cry')()

Hpkancha at 02:38, 28 September 2012

2012-09-28T02:38:16Z

@@ Line 46: / Line 46: @@
 ===Adding a method dynamically to a class===
 We can reopen an already existing class/prototype and add a new method to it dynamically. In ruby we reopen the class simply using the class keyword. In Javascript we grab the prototype for our object and just attach a new function.
 ====Python====
@@ Line 55: / Line 75: @@
     adam.battle_cry()
     # => Adam says zing!!!
 ====JavaScript====
-   Ninja.prototype.battleCry = function () {
+  drew['battleCry']();
-    puts(this.name + " says zing!!!");
+  // => Drew says zing!!!
-====Ruby====
+====Python====
-  class Ninja
+   drew.__getattribute__('battle_cry')()
    # => Drew says zing!!!
 ==Putting it all together==

← Older revision		Revision as of 04:54, 28 September 2012
Line 158:		Line 158:
	==References==		==References==
	Websites:		Websites:
	*Wikipedia.org: Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming		#Metaprogramming, http://en.wikipedia.org/wiki/Metaprogramming
	*Wikipedia.org: Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language		#Dynamic Programming Languages, http://en.wikipedia.org/wiki/Dynamic_programming_language
	*Wikipedia.org: Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface		#Application Programming Interfaces (API's), http://en.wikipedia.org/wiki/Application_programming_interface
	*http://www.linuxjournal.com/article/9604		#http://www.linuxjournal.com/article/9604
	*http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html		#http://www.ibm.com/developerworks/linux/library/l-metaprog1/index.html
	*http://tratt.net/laurie/research/publications/html/tratt__dynamically_typed_languages/		#http://tratt.net/laurie/research/publications/html/tratt__dynamically_typed_languages/
	*http://www.sitepoint.com/typing-versus-dynamic-typing/		#http://www.sitepoint.com/typing-versus-dynamic-typing/
	*http://www.bias2build.com/thesis/ruby_v_js_MP.html		#http://www.bias2build.com/thesis/ruby_v_js_MP.html
	*http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/		#http://codeblog.dhananjaynene.com/2010/01/dynamically-adding-methods-with-metaprogramming-ruby-and-python/
	*http://www.ibm.com/developerworks/linux/library/l-pymeta/index.html		#http://fingernailsinoatmeal.com/post/292301859/metaprogramming-ruby-vs-javascript
			#http://www.ibm.com/developerworks/linux/library/l-pymeta/index.html

	Books/Articles:		Books/Articles:
	*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846		*Tratt, L. 2005. Compile-time meta-programming in a dynamically typed OO language. In Proceedings of the 2005 Symposium on Dynamic Languages (San Diego, California, October 18 - 18, 2005). DLS '05. ACM, New York, NY, 49-63. http://doi.acm.org.www.lib.ncsu.edu:2048/10.1145/1146841.1146846
	*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538		*Madsen, O.L.; Nogaard, C.; , "An object-oriented metaprogramming system," System Sciences, 1988. Vol.II. Software Track, Proceedings of the Twenty-First Annual Hawaii International Conference on , vol.2, no., pp.406-415, 5-8 Jan 1988, http://ieeexplore.ieee.org.www.lib.ncsu.edu:2048/stamp/stamp.jsp?tp=&arnumber=11831&isnumber=538