sl-unit2 ppt for cse in b.tech jntuh iii year

sl

1. Unit-II Extended Ruby Syllabus Extending Ruby: Ruby Objects in C, the Jukebox extension, Memory allocation, Ruby Type System, Embedding Ruby to Other Languages, Embedding a Ruby Interpreter 1

2. Extended Ruby Ruby is a object oriented, reflective, general purpose, dynamic programming language. It is an interpreted scripting language which means most of its implementations execute instructions directly & freely , without previously compiling a program into machine language instructions. 2

3. Extended Ruby It is easy to extend Ruby with new features by writing code in Ruby. Once you start adding in low level code written in C , however, the possibilities are endless. 3

4. Ruby Objects in C Everything in Ruby is an object , and all variables are references to objects. Most Ruby objects are represented as C pointers to an area in memory that contains the object’s data and other implementation details. 4

5. Ruby Objects in C This is how Ruby implements object-oriented code in C: a Ruby object is an allocated structure in memory that contains a table of instance variables and information about the class. The class itself is another object (an allocated structure in memory) that contains a table of the methods defined for that class. 5

6. Ruby Objects in C How to represent and access Ruby data-types from within C. Everything in Ruby is an object, and all variables are references to objects. In C, this means that the type of all Ruby variables is  VALUE, which is either a 1. pointer to a Ruby object (VALUE as a pointer) or 2. An immediate value (such as  Fixnum ) 6

7. Ruby Objects in C 1. VALUE as a Pointer When  VALUE is a pointer , it is a pointer to one of the defined Ruby object structures---you can't have a VALUE that points to an arbitrary structure. The structures for each built-in class are defined in `` ruby.h '' and are named  R Classname , as in  RString  and  RArray . 7

8. Ruby Objects in C 2. VALUE as an Immediate Object immediate values are not pointers :   Fixnum , Symbol, true, false, and nil  are stored directly in VALUE. The other immediate values (true, false, and nil) are represented in C as the constants  Qtrue ,  Qfalse , and  Qnil , respectively. You can test VALUE variables against these constants directly, or use the conversion macros  8

9. Ruby Objects in C Working with immediate objects FIXNUM_P(value)  Non zero if value is a fixnum SYMBOL_P(value)  non zero if value is a symbol NIL_P(value)  Non zero if value is nil RTEST (value)  Non Zero if value if neither nil or false. 9

10. Writing Ruby in C We can write Ruby programs almost directly in C That is, you can use the same methods and the same logic, but with slightly different syntax to accommodate C. For instance, here is a small, fairly test class written in Ruby. class Test    def initialize      @ arr  =  Array.new    end    def add( anObject )      @ arr.push ( anObject )    end end 10

11. Writing Ruby in C #include “ ruby.h ” static VALUE t_init (VALUE self) { VALUE arr ; arr = rb_ary_new (); rb_iv_set (self, "@ arr ", arr ); return self; } static VALUE t_add (VALUE self, VALUE anObject ) { VALUE arr ; arr = rb_iv_get (self, "@ arr "); rb_ary_push ( arr , anObject ); return arr ; } VALUE cTest ; void Init_Test () { cTest = rb_define_class ("Test", rb_cObject ); rb_define_method ( cTest , "initialize", t_init , 0); rb_define_method ( cTest , "add", t_add , 1); } The equivalent code in C should look somewhat familiar. 11

12. Working with strings In C, we are used to working with a null-terminated strings. Ruby strings, however, are more general & may well include embedded nulls. Ruby string objects are actually references to to an RString structure and the RString structure contains both a length and a pointer field. we can access the structure via the RString macros INT2NUM( int )  Fixnum or Bignum INT2FIX( int )  Fixnum (faster) CHR2FIX(char)  Fixnum rb_str_new2(char*) string C data-types to Ruby objects RSTRING_LEN( str )  Length of the Ruby String RSTRING_PTR( str )  Pointer to String storage RSTRING_END( str )Pointer to end of string 12

13. The Jukebox Extension Extending Ruby with C is pretty easy. For instance, suppose we are building a custom Internet-ready jukebox for the Sunset Diner and Grill. It will play MP3 audio files from a hard disk or audio CDs from a CD jukebox. We want to be able to control the jukebox hardware from a Ruby program. The hardware vendor gave us a C header file and a binary library to use; our job is to construct a Ruby object that makes the appropriate C function calls. 13

14. The Jukebox Extension Jukebox example---interfacing C code with Ruby and sharing data and behavior between the two worlds. Jukebox extension framework follows 4 steps API: C Data Type Wrapping Object Creation Allocation Functions Cloning Objects 14

15. The Jukebox Extension 1. Wrapping C structures Wrapping means binds all the vendors jukebox framework into a single unit to begin the Ruby. The vendor’s library that controls the audio CD jukebox units, and ready to wire it into Ruby. The vendor’s header file looks like this 15

16. The Jukebox Extension typedef struct _cdjb { int statusf; int request; void *data; char pending; int unit_id; void *stats; } CDJukebox; // Allocate a new CDJukebox structure CDJukebox *new_jukebox(void); // Assign the Jukebox to a player void assign_jukebox(CDJukebox * jb , int unit_id); // Deallocate when done (and take offline) void free_jukebox(CDJukebox * jb ); // Seek to a disc, track and notify progress void jukebox_seek(CDJukebox * jb,int disc,int track) void (*done)( CDJukebox * jb , int percent)); // Report a statistic double get_avg_seek_time ( CDJukebox * jb ); 16

17. The Jukebox Extension 17

18. The Jukebox Extension 18

19. The Jukebox Extension 2. Creating Objects The basic idea is simple. Let’s say you’re creating an objects of class CDPlayer in your Ruby program. cd = CDPlayer.new 19

20. The Jukebox Extension 3. Allocation function 20

21. The Jukebox Extension 4. Cloning Objects All Ruby objects can be copied using one of two methods, dup and clone. The two methods are similar: Both produce a new instance of their receiver’s class by calling the allocation function. Then they copy across any instance variables from the original. Clone then goes a bit further and copies the original’s singleton class and flags (which means clone is not extensible) 21

22. Memory Allocation To allocate memory in an extension that won't be used for object storage. In order to work correctly with the garbage collector. In Ruby memory allocation will invoke the garbage collector to try to allocate the claim space. In Ruby, memory allocation is done little bit more work than the standard  malloc . 22

23. Memory Allocation Type Description ALLOC(c-type) Allocates a c-type and casts the result to a pointer of that type. ALLOC_N(c-type, n) Allocates n c-type objects, where c-type is the literal name of the C type, not a variable of that type. REALLOC_N( var , c-type, n) Reallocates n c-types and assigns the result to  var , a pointer to a c-type. ALLOCA_N(c-type, n) Allocates memory for n objects of c-type on the stack---this memory will be automatically freed when the function that invokes  ALLOCA_N  returns. 23

24. Ruby Type System In Ruby, we rely less on the type (or class) an object and more on its capabilities . This is known as Duck Typing. Hence Duck Typing means an object type is defined by what it can do , not by what it is . Duck typing refers to the tendency of ruby to be less concerned with the class of an object and more concerned with what method can be called on it and what operations can be performed on it . 24

25. Ruby Type System In Ruby, we would use respond_to? or might simply supply pass on object to a method and to know that an exception will be raised if it is used improperly. If an object is walk like a duck and talk like a duck, ruby interpreter is happy to treat it as is were a duck. irb (main): ‘A String’.respond_to?(:to_str) true irb (main): 4.respond_to?(:to_str) false Irb (main): Exceptioin.new.respond_to?(:to_str) false The above examples are types of Duck typing. 25

26. Embedding Ruby to other languages Ruby vs Ruby on Rails Ruby vs C: Seminaries and Differences Ruby vs C++: Seminaries and Differences Ruby vs Java: Seminaries and Differences Ruby vs Perl: Seminaries and Differences Ruby vs PHP: Seminaries and Differences Ruby can be embedded into Hypertext Markup Language (HTML). 26

27. Difference between Ruby and Ruby on Rails : Ruby is a programming language whereas Ruby on Rails is a Web framework. Ruby is an Object Oriented, dynamic, interpreted scripting language whereas Ruby on Rails is an Open source Web application framework, which runs on the Ruby programming language. 27

28. Ruby  versus C : Similarities with C As with C, in Ruby,… Most of the operators are the same Strings go in double-quotes. Strings are mutable. same sort of command-line debugger available Just like man pages, you can read most docs in your terminal window—though using the  ri  command. 28

29. Ruby  versus C : Differences from C : Unlike C, in Ruby,… You don’t need to compile your code. You just run it directly. Objects are strongly typed (and variable names themselves have no type at all). There’s no macros or preprocessor. No casts. No pointers (nor pointer arithmetic). No typedefs , sizeof , nor enums . There are no header files. You just define your functions (usually referred to as “methods”) and classes in the main source code files. There’s no #define. Just use constants instead. All variables live on the heap. Further, you don’t need to free them yourself—the garbage collector takes care of that. Arguments to methods (i.e. functions) are passed by value, where the values are always object references. It’s require ' foo ' instead of #include < foo > or #include " foo ". There’s no semicolons ending lines. You go without parentheses for if and while condition expressions. Parentheses for method (i.e. function) calls are often optional. 29

30. Ruby  versus C++ Similarities with C++ As with C++,in Ruby You’ve got mostly the same operators (even ::). <<  public, private, and protected do similar jobs. Inheritance syntax is still only one character, but it’s < instead of :. Exceptions work in a similar manner, though the keyword names have been changed to protect the innocent. 30

31. Ruby  versus C++ Differences from C++: Unlike C++, in Ruby,… There’s no explicit references. That is, in Ruby, every variable is just an automatically dereferenced name for some object. Objects are strongly but  dynamically  typed.. The “constructor” is called initialize instead of the class name. All methods are always virtual. “Class” (static) variable names always begin with @@ (as in @@total_widgets). You don’t directly access member variables—all access to public member variables (known in Ruby as attributes) is via methods. Parentheses for method calls are usually optional. You can re-open a class anytime and add more methods. There’s only two container types: Array and Hash. There’s no type conversions. Multithreading is built-in. 31

32. Ruby  versus Java Similarities As with Java, in Ruby,… Memory is managed via a garbage collector. Objects are strongly typed. There are public, private, and protected methods. There are embedded doc tools (Ruby’s is called RDoc ). The docs generated by rdoc look very similar to those generated by javadoc . 32

33. Ruby  versus Java Differences: Unlike Java, in Ruby,… You don’t need to compile your code. You just run it directly. There are several different popular third-party GUI toolkits. Ruby users can try  WxRuby ,  FXRuby ,  Ruby-GNOME2 ,  Qt , or  Ruby Tk  for example. You use the end keyword after defining things like classes, instead of having to put braces around blocks of code. You have require instead of import. All member variables are private. From the outside, you access everything via methods. Parentheses in method calls are usually optional and often omitted. Everything is an object, including numbers like 2 and 3.14159. There’s no static type checking. Variable names are just labels. They don’t have a type associated with them. There are no type declarations. You just assign to new variable names as-needed and they just “spring up” (i.e. a = [1,2,3] rather than  int [] a = {1,2,3};). 33

34. Ruby  versus Java Differences: Unlike Java, in Ruby,… There’s no casting. Just call the methods. Your unit tests should tell you before you even run the code if you’re going to see an exception. It’s  foo = Foo.new ("hi") instead of  Foo foo = new Foo ("hi"). The constructor is always named “initialize” instead of the name of the class. You have “ mixins ” instead of interfaces. YAML tends to be favored over XML. It’s nil instead of null. 34

35. Ruby  versus  Java : Ruby based program runs directly as it is an interpreted scripting language whereas Java-based codes are first compiled then executed. Ruby does not have any data types as Java. In Ruby the constructor name is always “initialize” whereas in case of Java the constructor name is the name of the class. Ruby uses dynamic typing whereas Java uses static typing. 35

36. Ruby  versus Perl Similarities: As with Perl, in Ruby,… You’ve got a package management system, somewhat like CPAN (though it’s called  RubyGems ). Regexes are built right in. Bon appétit! There’s a fairly large number of commonly-used built-ins. Parentheses are often optional. Strings work basically the same. There’s a general delimited string and regex quoting syntax similar to Perl’s. It looks like %q{this} (single-quoted), or %Q{this} (double-quoted), and %w{this for a single-quoted list of words}. You % Q|can | %Q(use) % Q^other ^ delimiters if you like. You’ve got double- quotish variable interpolation, though it "looks #{like} this" (and you can put any Ruby code you like inside that #{}). You’ve got embedded doc tools (Ruby’s is called rdoc ). 36

37. Ruby  versus Perl Differences : Unlike Perl, in Ruby,… You don’t have the context-dependent rules like with Perl. A variable isn’t the same as the object to which it refers. Instead, it’s always just a reference to an object. Although $ and @ are used as the first character in variable names sometimes, rather than indicating type, they indicate scope ($ for globals , @ for object instance, and @@ for class attributes). Array literals go in brackets instead of parentheses. Composing lists of other lists does not flatten them into one big list. Instead you get an array of arrays. It’s def instead of sub. There’s no semicolons needed at the end of each line. 37

38. Ruby  versus Perl Differences : Unlike Perl, in Ruby,… Objects are strongly typed. You’ll be manually calling  foo.to_i ,  foo.to_s , etc., if you need to convert between types. There’s no  eq , ne,  lt ,  gt ,  ge , nor le. There’s no diamond operator (<>). You usually use  IO.some_method  instead. The fat comma => is only used for hash literals. There’s no  undef . In Ruby you have nil. nil is an object (like anything else in Ruby). It’s not the same as an undefined variable. It evaluates to false if you treat it like a boolean . When tested for truth, only false and nil evaluate to a false value. Everything else is true (including 0, 0.0, and "0"). 38

39. Ruby  versus  Perl : Perl is unorganized, messy because of its free nature whereas Ruby is a well-organized language. Perl has multiple variable types whereas Ruby has only one variable type reference to an object. Perl is less object-oriented whereas Ruby is more object-oriented programming language. Perl supports more Unicode properties than Ruby. 39

40. Ruby  versus PHP Similarities: As in PHP, in Ruby… Ruby is dynamically typed, like in PHP, so you don’t need to worry about having to declare variables. There are classes, and you can control access to them like in PHP 5 (public, protected and private). Some variables start with $, like in PHP (but not all). There’s  eval , too. You can use string interpolation. Instead of doing "$ foo is a $bar", you can do "#{ foo } is a #{bar}"—like in PHP, this doesn’t apply for single-quoted strings. Ruby has exceptions, like PHP 5. There’s a fairly large standard library. Arrays and hashes work like expected, if you exchange array() for { and }: array('a' => 'b') becomes {'a' => 'b'}. true and false behave like in PHP, but null is called nil. 40

41. Ruby  versus PHP Differences: Unlike in PHP, in Ruby… There’s strong typing. You’ll need to call to_s, to_i etc. to convert between strings, integers and so on, instead of relying on the language to do it. Strings, numbers, arrays, hashes, etc. are objects. Instead of calling abs(-1) it’s -1.abs. Parentheses are optional in method calls, except to clarify which parameters go to which method calls. The standard library and extensions are organized in modules and classes. Reflection is an inherent capability of objects, you don’t need to use Reflection classes like in PHP 5. Variables are references. There’s no abstract classes or interfaces. Hashes and arrays are not interchangeable. Only false and nil are false: 0, array() and "" are all true in conditionals. Almost everything is a method call, even raise (throw in PHP). 41

42. Ruby  versus  PHP : Web development and deployment is very simple with PHP as compared to Ruby. Using Ruby, Ruby on Rails was created for the designing of Web applications whereas PHP is designed for back-end Web development. Facebook is PHP based application whereas Twitter is Ruby-based application. PHP has a better performance on the basis of execution as compared to Ruby. PHP executes faster than Ruby as PHP has fewer lines of code as compared to Ruby 42

43. Ruby  versus Python Similarities: As with Python, in Ruby,… There’s an interactive prompt (called  irb ). You can read docs on the command line (with the  ri  command instead of  pydoc ). There are no special line terminators (except the usual newline). String literals can span multiple lines like Python’s triple-quoted strings. Brackets are for lists, and braces are for dicts (which, in Ruby, are called “hashes”). Arrays work the same Objects are strongly and dynamically typed. Everything is an object, and variables are just references to objects. You’ve got embedded doc tools (Ruby’s is called rdoc ). 43

44. Ruby  versus Python Differences: Unlike Python, in Ruby,… Strings are mutable. You can make constants (variables whose value you don’t intend to change). There are some enforced case-conventions (ex. class names start with a capital letter, variables start with a lowercase letter). There’s only one kind of list container (an Array), and it’s mutable. Double-quoted strings allow escape sequences (like \t) You never directly access attributes. With Ruby, it’s all method calls. Parentheses for method calls are usually optional. There’s public, private, and protected to enforce access, instead of Python’s _voluntary_ underscore __convention__. 44

45. Ruby  versus Python Differences: Unlike Python, in Ruby,… “ mixins ” are used instead of multiple inheritance. You can add or modify the methods of built-in classes. Both languages let you open up and modify classes at any point, but Python prevents modification of built-ins — Ruby does not. You’ve got true and false instead of True and False (and nil instead of None). When tested for truth, only false and nil evaluate to a false value. Everything else is true (including 0, 0.0, "", and []). It’s  elsif  instead of  elif . It’s require instead of import Python supports just one kind of anonymous functions, lambdas, while Ruby contains blocks, Procs , and lambdas. 45

46. Ruby  versus  Python : Ruby can be very hard to debug at times while Python is very explicit and easy to read. Usage of blocks are present in Ruby whereas usage of modules and better namespace handling are present in Python. Ruby based apps are Twitter, Github , Hulu etc. whereas Python-based apps are Youtube , Instagram , Bit torrent, etc. Ruby has a Web framework called Ruby on Rails whereas Python has a web framework called Django . 46

47. Embedding a Ruby Interpreter In addition to extending Ruby by adding C code, you can also turn the problem around and embed Ruby itself within your application. Here's an example. #include " ruby.h " main() {   /* ... our own application stuff ... */    r uby_init ();    ruby_script ("embedded");    rb_load_file (" start.rb ");    while  (1) {      if ( need_to_do_ruby )  {         ruby_run ();      }     /* ... run our app stuff */    } } 47

48. Embedding a Ruby Interpreter 48