Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2013/oss M801 as

2013-10-31T02:19:41Z

Tmuthuk: /* Appending an element and sending it to layout */

='''Dynamic style additions/removals'''=

This article is about the project M801 - Dynamic style additions/removals, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

Servo is a research project whose goal is to develop a new Web browser engine that makes use of parallelism at many levels while eliminating common sources of bugs and security vulnerabilities associated with incorrect memory management and data races. Given that C++ is poorly suited to prevent these problems, Servo is written in [http://en.wikipedia.org/wiki/Rust_%28programming_language%29 Rust programming language]. Rust <ref>http://en.wikipedia.org/wiki/Iterative_and_incremental_development</ref> provides a task-parallel infrastructure and a strong type system that enforces memory safety and data race freedom.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine.

===''Challenges''===

:*Performance. Parallel algorithms tend to involve tough trade offs and it must ensure that Rust itself has performance comparable to C++.
:*Data structures. Rust has new type system, specifically to enable safe parallel types and algorithms.
:*Language immaturity. The Rust compiler and language are yet to reach stability. Rust also has fewer libraries than C++ available. It is possible to bind to C++ libraries, but that involves more work than simply using the C++ header files.

===''What is this project about?''===

This project deals mainly with communicating between tasks.

:*Test cases for dynamically appending, removing or modifying elements that causes a visible change.
:*Recognize when an element is being appended and get the element to the layout.
:*Network requests and removal of newly added stylesheets.

=='''Work done so far'''==
====''Testing Dynamic elements in HTML''====
A test html code that runs successfully in Firefox/chrome is created first before testing the changes in Servo. The test cases are written in Javascript using the Document Object Model to manipulate the HTML elements. The test demonstrates the following:

:*appending a new link element that references a stylesheet.
:*appending a new style element that contains rule.
:*removing an existing link element that references a stylesheet.
:*remove an existing style element that contains rules.
:*modifying the content of a style element (such as removing all content).
:*modifying the href attribute of a link element that points at a stylesheet (such as referencing a new one that does not exist).

===''Appending an element and sending it to layout''===
The appendchild() method in [https://github.com/tmuthuk/servo/blob/master/src/components/script/dom/node.rs node.rs] file has been [http://en.wikipedia.org/wiki/Code_refactoring refactored] to recognize when a style element is appended in an HTML file. Whenever a style element is appended, [https://github.com/mozilla/servo/blob/master/src/components/script/html/cssparse.rs CSS parser] need to be invoked that parses through the content present within the [http://www.w3schools.com/tags/tag_style.asp style element] and renders the output to the Layout task with all the CSS rules applied on the HTML content. Previously, the CSS style rules were applied only when the rules are appended using link element as an external stylesheet.

'''Functionality Added :''' First the code will check whether the new child node that has been appended is a style node. If yes, A dummy URL is set into the URL variable, and the content that is present within the style tag is wrapped by "NodeWrapping" implementation and stored in a variable called "data" Then both URL and data are assigned to Inline Provenance - A member of enum variable "CSSTaskNewFile" that CSS parser uses to differentiate between link element and style element. Then css_spawn_parser method is called which does the parsing and renders the output to the Layout Task.

The following two files were modified to include the new code.

:*'''[https://github.com/tmuthuk/servo/blob/master/src/test/html/content/test_collections.html test_collections.html]'''
:*'''[https://github.com/tmuthuk/servo/blob/master/src/components/script/dom/node.rs node.rs]'''

Below is a pictorial representation of the servo task communication
[[File:task.jpg|center|alt=Sample task communication diagram| Fig 1: Servo Task Communication diagram]]

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/mozilla/servo Build Servo] <ref> https://github.com/mozilla/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2013/oss M801 as

2013-10-31T02:18:48Z

Tmuthuk: /* Appending an element and sending it to layout */

='''Dynamic style additions/removals'''=

This article is about the project M801 - Dynamic style additions/removals, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

Servo is a research project whose goal is to develop a new Web browser engine that makes use of parallelism at many levels while eliminating common sources of bugs and security vulnerabilities associated with incorrect memory management and data races. Given that C++ is poorly suited to prevent these problems, Servo is written in [http://en.wikipedia.org/wiki/Rust_%28programming_language%29 Rust programming language]. Rust <ref>http://en.wikipedia.org/wiki/Iterative_and_incremental_development</ref> provides a task-parallel infrastructure and a strong type system that enforces memory safety and data race freedom.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine.

===''Challenges''===

:*Performance. Parallel algorithms tend to involve tough trade offs and it must ensure that Rust itself has performance comparable to C++.
:*Data structures. Rust has new type system, specifically to enable safe parallel types and algorithms.
:*Language immaturity. The Rust compiler and language are yet to reach stability. Rust also has fewer libraries than C++ available. It is possible to bind to C++ libraries, but that involves more work than simply using the C++ header files.

===''What is this project about?''===

This project deals mainly with communicating between tasks.

:*Test cases for dynamically appending, removing or modifying elements that causes a visible change.
:*Recognize when an element is being appended and get the element to the layout.
:*Network requests and removal of newly added stylesheets.

=='''Work done so far'''==
====''Testing Dynamic elements in HTML''====
A test html code that runs successfully in Firefox/chrome is created first before testing the changes in Servo. The test cases are written in Javascript using the Document Object Model to manipulate the HTML elements. The test demonstrates the following:

:*appending a new link element that references a stylesheet.
:*appending a new style element that contains rule.
:*removing an existing link element that references a stylesheet.
:*remove an existing style element that contains rules.
:*modifying the content of a style element (such as removing all content).
:*modifying the href attribute of a link element that points at a stylesheet (such as referencing a new one that does not exist).

===''Appending an element and sending it to layout''===
The appendchild() method in [https://github.com/tmuthuk/servo/blob/master/src/components/script/dom/node.rs node.rs] file has been [http://en.wikipedia.org/wiki/Code_refactoring refactored] to recognize when a style element is appended in an HTML file. Whenever a style element is appended, [https://github.com/mozilla/servo/blob/master/src/components/script/html/cssparse.rs CSS parser] need to be invoked that parses through the content present within the [http://www.w3schools.com/tags/tag_style.asp style element] and renders the output to the Layout task with all the CSS rules applied on the HTML content. Previously, the CSS style rules were applied only when the rules are appended using link element as an external stylesheet.

Functionality Added : First the code will check whether the new child node that has been appended is a style node. If yes, A dummy URL is set into the URL variable, and the content that is present within the style tag is wrapped by "NodeWrapping" implementation and stored in a variable called "data" Then both URL and data are assigned to Inline Provenance - A member of enum variable "CSSTaskNewFile" that CSS parser uses to differentiate between link element and style element. Then css_spawn_parser method is called which does the parsing and renders the output to the Layout Task.

The following two files were modified to include the new code.

:*'''[https://github.com/tmuthuk/servo/blob/master/src/test/html/content/test_collections.html test_collections.html]'''
:*'''[https://github.com/tmuthuk/servo/blob/master/src/components/script/dom/node.rs node.rs]'''

Below is a pictorial representation of the servo task communication
[[File:task.jpg|center|alt=Sample task communication diagram| Fig 1: Servo Task Communication diagram]]

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/mozilla/servo Build Servo] <ref> https://github.com/mozilla/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2013/oss M801 as

2013-10-31T02:16:04Z

Tmuthuk: /* Appending an element and sending it to layout */

='''Dynamic style additions/removals'''=

This article is about the project M801 - Dynamic style additions/removals, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

Servo is a research project whose goal is to develop a new Web browser engine that makes use of parallelism at many levels while eliminating common sources of bugs and security vulnerabilities associated with incorrect memory management and data races. Given that C++ is poorly suited to prevent these problems, Servo is written in [http://en.wikipedia.org/wiki/Rust_%28programming_language%29 Rust programming language]. Rust <ref>http://en.wikipedia.org/wiki/Iterative_and_incremental_development</ref> provides a task-parallel infrastructure and a strong type system that enforces memory safety and data race freedom.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine.

===''Challenges''===

:*Performance. Parallel algorithms tend to involve tough trade offs and it must ensure that Rust itself has performance comparable to C++.
:*Data structures. Rust has new type system, specifically to enable safe parallel types and algorithms.
:*Language immaturity. The Rust compiler and language are yet to reach stability. Rust also has fewer libraries than C++ available. It is possible to bind to C++ libraries, but that involves more work than simply using the C++ header files.

===''What is this project about?''===

This project deals mainly with communicating between tasks.

:*Test cases for dynamically appending, removing or modifying elements that causes a visible change.
:*Recognize when an element is being appended and get the element to the layout.
:*Network requests and removal of newly added stylesheets.

=='''Work done so far'''==
====''Testing Dynamic elements in HTML''====
A test html code that runs successfully in Firefox/chrome is created first before testing the changes in Servo. The test cases are written in Javascript using the Document Object Model to manipulate the HTML elements. The test demonstrates the following:

:*appending a new link element that references a stylesheet.
:*appending a new style element that contains rule.
:*removing an existing link element that references a stylesheet.
:*remove an existing style element that contains rules.
:*modifying the content of a style element (such as removing all content).
:*modifying the href attribute of a link element that points at a stylesheet (such as referencing a new one that does not exist).

===''Appending an element and sending it to layout''===
The appendchild() method in [https://github.com/tmuthuk/servo/blob/master/src/components/script/dom/node.rs node.rs] file has been [http://en.wikipedia.org/wiki/Code_refactoring refactored] to recognize when a style element is appended in an HTML file. Whenever a style element is appended, [https://github.com/mozilla/servo/blob/master/src/components/script/html/cssparse.rs CSS parser] need to be invoked that parses through the content present within the [http://www.w3schools.com/tags/tag_style.asp style element] and renders the output to the Layout task with all the CSS rules applied on the HTML content. Previously, the CSS style rules were applied only when the rules are appended using link element as an external stylesheet.

Functionality Added : First the code will check whether the new child node that has been appended is a style node. If yes, A dummy URL is set into the URL variable, and the content that is present within the style tag is wrapped by "NodeWrapping" implementation and stored in a variable called "data" Then both URL and data are assigned to Inline Provenance - A member of enum variable "CSSTaskNewFile" that CSS parser uses to differentiate between link element and style element. Then css_spawn_parser method is called which does the parsing and renders the output to the Layout Task.

The following two files were modified to include the new code.

:*'''test_collections.html'''
:*'''node.rs'''

Below is a pictorial representation of the servo task communication
[[File:task.jpg|center|alt=Sample task communication diagram| Fig 1: Servo Task Communication diagram]]

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/mozilla/servo Build Servo] <ref> https://github.com/mozilla/servo </ref>

=='''References'''==
<references/>

CSC/ECE 517 Fall 2013/oss M801 as

2013-10-31T02:10:13Z

Tmuthuk: /* Appending an element and sending it to layout */

='''Dynamic style additions/removals'''=

This article is about the project M801 - Dynamic style additions/removals, which is a part of the ongoing development on the Servo browser. Here you can find a brief description about the servo project, rust programming language, requirements of this particular project, setting up of the development environment and other relevant details.

__TOC__

== '''Introduction''' ==
==='' What is Servo?''===

Servo is a research project whose goal is to develop a new Web browser engine that makes use of parallelism at many levels while eliminating common sources of bugs and security vulnerabilities associated with incorrect memory management and data races. Given that C++ is poorly suited to prevent these problems, Servo is written in [http://en.wikipedia.org/wiki/Rust_%28programming_language%29 Rust programming language]. Rust <ref>http://en.wikipedia.org/wiki/Iterative_and_incremental_development</ref> provides a task-parallel infrastructure and a strong type system that enforces memory safety and data race freedom.

Servo is explicitly not aiming to create a full Web browser (except for demonstration and experimentation purposes). Rather it is focused on creating a solid, embeddable engine.

===''Challenges''===

:*Performance. Parallel algorithms tend to involve tough trade offs and it must ensure that Rust itself has performance comparable to C++.
:*Data structures. Rust has new type system, specifically to enable safe parallel types and algorithms.
:*Language immaturity. The Rust compiler and language are yet to reach stability. Rust also has fewer libraries than C++ available. It is possible to bind to C++ libraries, but that involves more work than simply using the C++ header files.

===''What is this project about?''===

This project deals mainly with communicating between tasks.

:*Test cases for dynamically appending, removing or modifying elements that causes a visible change.
:*Recognize when an element is being appended and get the element to the layout.
:*Network requests and removal of newly added stylesheets.

=='''Work done so far'''==
====''Testing Dynamic elements in HTML''====
A test html code that runs successfully in Firefox/chrome is created first before testing the changes in Servo. The test cases are written in Javascript using the Document Object Model to manipulate the HTML elements. The test demonstrates the following:

:*appending a new link element that references a stylesheet.
:*appending a new style element that contains rule.
:*removing an existing link element that references a stylesheet.
:*remove an existing style element that contains rules.
:*modifying the content of a style element (such as removing all content).
:*modifying the href attribute of a link element that points at a stylesheet (such as referencing a new one that does not exist).

===''Appending an element and sending it to layout''===
The appendchild() method in node.rs file has been refactored to recognize when a style element is appended in an HTML file. Whenever a style element is appended, CSS parser need to be invoked that parses through the content present within the style element and renders the output to the Layout task with all the CSS rules applied on the HTML content. Previously, the CSS style rules were applied only when the rules are appended using link element as an external stylesheet.

Functionality Added : First the code will check whether the new child node that has been appended is a style node. If yes, A dummy URL is set into the URL variable, and the content that is present within the style tag is wrapped by "NodeWrapping" implementation and stored in a variable called "data" Then both URL and data are assigned to Inline Provenance - A member of enum variable "CSSTaskNewFile" that CSS parser uses to differentiate between link element and style element. Then css_spawn_parser method is called which does the parsing and renders the output to the Layout Task.

The following two files were modified to include the new code.

:*'''test_collections.html'''
:*'''node.rs'''

Below is a pictorial representation of the servo task communication
[[File:task.jpg|center|alt=Sample task communication diagram| Fig 1: Servo Task Communication diagram]]

=='''Appendix'''==
===''Setting up Servo''===
There are two main steps to set up the environment for this project. Linux environment is preferred for setting up the environment as it is simple and easy.

:* [https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust Build Rust] <ref> https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust </ref>
:* [https://github.com/mozilla/servo Build Servo] <ref> https://github.com/mozilla/servo </ref>

=='''References'''==
<references/>

File:SerializationChart.jpg

2013-09-25T01:54:46Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg"

File:SerializationChart.jpg

2013-09-25T01:53:07Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg"

File:SerializationChart.jpg

2013-09-25T01:52:02Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg"

File:SerializationChart.jpg

2013-09-25T01:50:32Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg": Reverted to version as of 14:59, 18 September 2013

File:SerializationChart.jpg

2013-09-25T01:50:20Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg": Reverted to version as of 01:48, 25 September 2013

File:SerializationChart.jpg

2013-09-25T01:49:35Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg"

File:SerializationChart.jpg

2013-09-25T01:48:51Z

Tmuthuk: uploaded a new version of "File:SerializationChart.jpg"

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-25T01:38:16Z

Tmuthuk:

== '''Serialization''' ==

'''Serialization'''[http://en.wikipedia.org/wiki/Serialization] is the process of converting an object or a group of objects into a stream of bytes or string to facilitate storage in memory or transmission over a network. The process of Serialization is also referred to as ''Marshalling''. The stream of data has to be in a format that can be understood by both ends of a communication channel so that the object can be marshaled and reconstructed easily.

'''Basic Advantages of Serialization''':

1.Facilitates the easy transportation of an object through a network.

2.Creates a clone of the object at the receiving end.

3.Ability to transmit data across the network in a cross-platform-compatible format.

4.Saving the data in a persistent or non-persistent storage medium in a non-proprietary format.

'''De-serialization''' is the process of converting the stream of bytes or string back to objects in memory. It is the process of reconstructing the object later.This process of de-serialization is also referred to as ''Unmarshalling''.

[[File:SerializationChart.jpg]]

== '''Serialization in Ruby:''' ==

Let us consider a situation where two Ruby programs have to communicate with each other. One of the simplest way to do this is to convert the Ruby objects in the first programs into strings and writing these strings into a file. This is nothing but serialization. The second program can read this file and convert the strings back into Ruby objects. This is de-serialization.

== '''Types of Serialization''' ==

Serialization in Ruby can be done in two ways. During serialization, the object in memory can be converted into Human Readable formats like YAML (YAML Ain’t Markup Language) and JSON (JavaScript Object Notation), or the object can be converted into binary format.

=== Converting Ruby Objects in Human Readable Formats ===
The conversion of Ruby objects into YAML and JSON formats are explained below.

==== Converting Ruby Objects to YAML format ====

YAML[http://yaml.org/] format is a human friendly data serialization standard for all programming languages. YAML (YAML Ain't Markup Language) is perhaps the most common form of serialization in Ruby applications. It is used for configuration files in Rails and other projects, and is nearly ubiquitous. YAML is a plaintext format, as opposed to Marshal's[http://www.ruby-doc.org/core-2.0.0/Marshal.html] binary format. Immediately, this makes things easier. Objects stored as YAML are completely transparent and editable with nothing more than a text editor. It also has a simple, spartan syntax that's easy to look at and easy to type. It is not encumbered by excessive wordage and symbols seen in XML. Any Ruby object can easily be serialized into YAML format. Let us consider the below code,<

<nowiki>require "yaml"
class First
def initialize(name, age, country)
@name = name
@age = age
@country=country
end

def to_s
"In First:\n#{@name}, #{@age}, #{@country}\n"
end
end

class Second
def initialize(address, details)
@address = address
@details = details
end

def to_s
"In Second:\n#{@details.to_s}#{@address}\n"
end
end

x = First.new("Tom", 25, "USA")
y = Second.new("St. Marks Street", x)
puts y</nowiki>

We get the string representation of the object tree(object hierarchy) as the Output (because we have used the function to_s[http://ruby-doc.org/core-2.0.0/Object.html#method-i-to_s]).

'''Output''':

<code>
In Second:<br>
In First:<br>
Tom, 25, USA<br>
St. Marks Street</code>

We use the below code to serialize out object tree.

<code>serialized_object = YAML::dump(y)
puts serialized_object</code>

The dump function serializes the object tree and stores the data in the YAML format in the variable serialized_object.

Data in the serialized (YAML) format looks like this:

<code>
--- !ruby/object:Second
address: St. Marks Street
details: !ruby/object:First
name: Tom
age: 25
country: USA</code>

Now, to de-serialize the data, we use load function.

<code>puts YAML::load(serialized_object)</code>

The data is converted back to Ruby object tree.

'''Output:'''

<code>In Second:
In First:
Tom, 25, USA
St. Marks Street
</code>

Thus we get back our original Object tree.

==== Converting Ruby Objects to JSON format: ====

JSON[http://www.json.org/] is a light-weight data interchange format. JSON is typically generated by web applications and can be quite daunting, with deep hierarchies that are difficult to navigate. Any Ruby object can easily be serialized into JSON format. On Ruby 1.8.7, you'll need to install a gem. However, in Ruby 1.9.2, the json gem is bundled with the core Ruby distribution. So, if you're using 1.9.2, you're probably all set. If you're on 1.8.7, you'll need to install a gem.[http://ruby.about.com/od/tasks/a/The-Json-Gem.htm]
The JSON library can be installed using Ruby Gems[http://rubygems.org/] like shown below:

<code># gem install json</code>

We can create a JSON string for serialization by using the JSON.generate method as below:

<code>
require 'json'
my_hash = {:Welcome => "Ruby"}
puts JSON.generate(my_hash) => "{\"WELCOME\":\"RUBY\"}"
</code>

'''Output:'''

<code>{"{\"Welcome\":\"Ruby\"}"=>"{\"WELCOME\":\"RUBY\"}"}</code>

We can parse the JSON string received from another program by using JSON.parse
Ruby thus converts String to Hash.

<code>
require 'json'
my_hash = JSON.parse('{"Welcome": "Ruby"}')
puts my_hash["Welcome"] => "Ruby"
</code>

=== Converting Ruby Objects to Binary Formats ===
Binary Serialization is another form of serialization in Ruby which is not in human readable form. It is similar to YAML Serialization. Binary Serialization is done using Marshal[http://www.ruby-doc.org/core-2.0.0/Marshal.html]. Binary Serialization is used when high performance serialization and de-serialization process is required and when the contents are not required to be in readable format.

Since the Binary Serialized data is not in human readable form, there are two essential guidelines that need to be followed. They are :
1.Use print[http://ruby-doc.org/core-2.0.0/ARGF.html#method-i-print] instead of puts[http://ruby-doc.org/core-2.0.0/ARGF.html#method-i-puts] when serialized objects are written to a file in order to avoid new line characters to be written
in the file.

2.Use a record separator in order to differentiate between two objects.

<code>Binary Serialization Example </code>

<code>
class Animal
def initialize name, age
@name = name
@age=age
puts "#{self.class.name}"
end
end
class Cat < Animal
def to_s
"In Cat C: #{@name} \t #{@age}"
end
end
class Dog < Animal
def to_s
puts "In Dog D: #{@name} \t #{@age}"
end
end
d = Dog.new("Doggy Dig", 4)
c = Cat.new("Kitty Kat",5)
puts "Before Serialization"
puts c
puts d
serialize_cat= Marshal.dump(c) #dumps the serialized cat object into serialize_cat
serialize_dog= Marshal.dump(d) #dumps the serialized dog object into serialize_dog
deserialize_cat= Marshal::load(serialize_cat) #deserializes the cat object and loads it back into deserialize_cat
deserialize_dog= Marshal::load(serialize_dog) #deserializes the dog object and loads it back into deserialize_dog
puts "After Serialization #{deserialize_cat}"
puts "After Dog Serialization #{deserialize_dog}"
</code>

Output
<code>
Before Serialization
In Cat C: Kitty Kat 5
In Dog D: Doggy Dig 4
After Serialization In Cat C: Kitty Kat 5
After Dog Serialization In Dog D: Doggy Dig 4
</code>

== Serialization in OOLS Languages: Comparison ==
{| class="wikitable"
|-
! Sl.No !! Ruby !! Java !! .Net Framework
|-
| 1 || Ruby provides a module called [http://www.ruby-doc.org/core-2.0.0/Marshal.html Marshal] for serialization || Java uses an Interface named [http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html Serializable] interface for classes to implement || .Net provides a [http://msdn.microsoft.com/en-us/library/ms973893.aspx Serializable] Attribute
|-
| 2 || Ruby uses JSON to make it platform independent || An object can be serialized in one platform and de-serialized in another platform || .Net used Remoting technology to make it platform independent.
|-
| 3 || Ruby serializes an Object as a whole.|| Provides an option for serializing only the required methods/attributes to be serialized for an object. Use the keyword [http://docs.oracle.com/javase/7/docs/platform/serialization/spec/serial-arch.html Transient] to ignore certain methods that doesn’t need to be serialized || [http://msdn.microsoft.com/en-us/library/ms973893.aspx XML Serializer] sets [http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlattributes.xmlignore.aspx XmlIgnoreProperty] to true to ignore the default serialization of a field or a property
|}

== See Also==

1. [http://www.ruby-doc.org/stdlib-1.9.3/libdoc/json/rdoc/JSON.html Serialization in Ruby JSON]

2. [http://api.rubyonrails.org/classes/ActiveModel/Serialization.html Serialization in Rails]

3. [http://gregmoreno.wordpress.com/2011/01/27/preventing-model-explosion-via-rails-serialization/ Article on Rails Serialization]
== References ==

1. [http://en.wikipedia.org/wiki/Serialization Serilization in General]

2. [http://yaml.org YAML]

3. [http://www.w3schools.com/json/ JSON]

4. [http://www.skorks.com/2010/04/serializing-and-deserializing-objects-with-ruby/ Serializing and De-serializing in Ruby]

5. [http://www.codeproject.com/Articles/33296/Serialization-and-De-serialization Serialization and De-serialization]

6. [http://www.ruby-doc.org/core-2.0.0/Marshal.html Marshal]

7. [http://www.waset.org/journals/waset/v60/v60-39.pdf Object Serialization Techniques]

8. [http://msdn.microsoft.com/en-us/library/182eeyhh.aspx XML Serialization]

9. [http://www.tutorialspoint.com/java/java_serialization.htm Java Serialization]

10.[http://www.codeproject.com/Articles/20962/Introducing-Serialization-in-NET Serialization in .Net]

11.[http://json.org JSON]

12.[http://ruby.about.com/od/advancedruby/ss/Serialization-In-Ruby-Yaml.html Serialization in Ruby YAML]

13.[http://ruby.about.com/od/tasks/a/The-Json-Gem.html Installing JSON gem]

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T07:39:04Z

Tmuthuk: /* Converting Ruby Objects to Binary Formats */

== '''Serialization''' ==

'''Serialization'''[http://en.wikipedia.org/wiki/Serialization] is the process of converting an object or a group of objects into a stream of bytes or string to facilitate storage in memory or transmission over a network. The process of Serialization is also referred to as ''Marshalling''. The stream of data has to be in a format that can be understood by both ends of a communication channel so that the object can be marshaled and reconstructed easily.

'''Basic Advantages of Serialization''':

1.Facilitates the easy transportation of an object through a network.

2.Creates a clone of the object at the receiving end.

3.Ability to transmit data across the network in a cross-platform-compatible format.

4.Saving the data in a persistent or non-persistent storage medium in a non-proprietary format.

'''De-serialization''' is the process of converting the stream of bytes or string back to objects in memory. It is the process of reconstructing the object later.This process of de-serialization is also referred to as ''Unmarshalling''.

[[File:SerializationChart.jpg]]

== '''Serialization in Ruby:''' ==

Let us consider a situation where two Ruby programs have to communicate with each other. One of the simplest way to do this is to convert the Ruby objects in the first programs into strings and writing these strings into a file. This is nothing but serialization. The second program can read this file and convert the strings back into Ruby objects. This is de-serialization.

[[File:Types.jpg]]

== '''Types of Serialization''' ==

Serialization in Ruby can be done in two ways. During serialization, the object in memory can be converted into Human Readable formats like YAML (YAML Ain’t Markup Language) and JSON (JavaScript Object Notation), or the object can be converted into binary format.

=== Converting Ruby Objects in Human Readable Formats ===

==== Converting Ruby Objects to YAML format ====

YAML[http://yaml.org/] format is a human friendly data serialization standard for all programming languages. Any Ruby object can easily be serialized into YAML format. Let us consider the below code,

<code>require "yaml"</code>
<nowiki>class First
def initialize(name, age, country)
@name = name
@age = age
@country=country
end

def to_s
"In First:\n#{@name}, #{@age}, #{@country}\n"
end
end

class Second
def initialize(address, details)
@address = address
@details = details
end

def to_s
"In Second:\n#{@details.to_s}#{@address}\n"
end
end

x = First.new("Tom", 25, "USA")
y = Second.new("St. Marks Street", x)
puts y</nowiki>

We get the string representation of the object tree as the Output (because we have used the function to_s[http://ruby-doc.org/core-2.0.0/Object.html#method-i-to_s]).

'''Output''':

<code>
In Second:
In First:
Tom, 25, USA
St. Marks Street</code>

We use the below code to serialize out object tree.

<code>serialized_object = YAML::dump(y)
puts serialized_object</code>

The dump function serializes the object tree and stores the data in the YAML format in the variable serialized_object.

Data in the serialized (YAML) format looks like this:

<code>
--- !ruby/object:Second
address: St. Marks Street
details: !ruby/object:First
name: Tom
age: 25
country: USA</code>

Now, to de-serialize the data, we use load function.

<code>puts YAML::load(serialized_object)</code>

The data is converted back to Ruby object tree.

'''Output:'''

<code>In Second:
In First:
Tom, 25, USA
St. Marks Street
</code>

Thus we get back our original Object tree.

==== Converting Ruby Objects to JSON format: ====

JSON[http://www.json.org/] is a light-weight data interchange format. Any Ruby object can easily be serialized into JSON format.
The JSON library can be installed using Ruby Gems[http://rubygems.org/] like shown below:

<code># gem install json</code>

We can create a JSON string for serialization by using the JSON.generate method as below:

<code>
require 'json'
my_hash = {:Welcome => "Ruby"}
puts JSON.generate(my_hash) => "{\"WELCOME\":\"RUBY\"}"</code>

'''Output:'''

<code>{"{\"Welcome\":\"Ruby\"}"=>"{\"WELCOME\":\"RUBY\"}"}</code>

We can parse the JSON string received from another program by using JSON.parse
Ruby thus converts String to Hash.

<code>require 'json'
my_hash = JSON.parse('{"Welcome": "Ruby"}')
puts my_hash["Welcome"] => "Ruby"</code>

=== Converting Ruby Objects to Binary Formats ===
Binary Serialization is another form of serialization in Ruby which is not in human readable form. It is similar to YAML Serialization. Binary Serialization is done using Marshal[http://www.ruby-doc.org/core-2.0.0/Marshal.html]. Binary Serialization is used when high performance serialization and de-serialization process is required and when the contents are not required to be in readable format.

Since the Binary Serialized data is not in human readable form, there are two essential guidelines that need to be followed. They are :
1.Use print[http://ruby-doc.org/core-2.0.0/ARGF.html#method-i-print] instead of puts[http://ruby-doc.org/core-2.0.0/ARGF.html#method-i-puts] when serialized objects are written to a file in order to avoid new line characters to be written
in the file.

2.Use a record separator in order to differentiate between two objects.
<code>Binary Serialization Example </code>

<code>
class Animal
def initialize name, age
@name = name
@age=age
puts "#{self.class.name}"
end
end
class Cat < Animal
def to_s
"In Cat C: #{@name} \t #{@age}"
end
end
class Dog < Animal
def to_s
puts "In Dog D: #{@name} \t #{@age}"
end
end
d = Dog.new("Doggy Dig", 4)
c = Cat.new("Kitty Kat",5)
puts "Before Serialization"
puts c
puts d
serialize_cat= Marshal.dump(c)
serialize_dog= Marshal.dump(d)
deserialize_cat= Marshal::load(serialize_cat)
deserialize_dog= Marshal::load(serialize_dog)
puts "After Serialization #{deserialize_cat}"
puts "After Dog Serialization #{deserialize_dog}"
</code>

Output
<code>
Before Serialization
In Cat C: Kitty Kat 5
In Dog D: Doggy Dig 4
After Serialization In Cat C: Kitty Kat 5
After Dog Serialization In Dog D: Doggy Dig 4
</code>

== Serialization in OOLS Languages: Comparison ==
{| class="wikitable"
|-
! Sr.No !! Ruby !! Java !! .Net Framework
|-
| 1 || Ruby provides a module called ‘Marshal'[http://www.ruby-doc.org/core-2.0.0/Marshal.html] for serialization || Java uses an Interface named ‘Serializable’[http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html] interface for classes to implement || .Net provides a ‘Serializable’[http://msdn.microsoft.com/en-us/library/ms973893.aspx] Attribute
|-
| 2 || Ruby uses JSON to make it platform independent || An object can be serialized in one platform and de-serialized in another platform || .Net used Remoting technology to make it platform independent.
|-
| 3 || Ruby serializes an Object as a whole.|| Provides an option for serializing only the required methods/attributes to be serialized for an object. Use the keyword ‘Transient’ to ignore certain methods that doesn’t need to be serialized || XML Serializer[http://msdn.microsoft.com/en-us/library/ms973893.aspx] will not serialize not convert methods, indexers, private fields, or read-only properties.
|}
== References ==
1. http://wikipedia.org

2. http://yaml.org

3. http://www.ruby-doc.org

4. http://www.w3schools.com

5. http://www.skorks.com/2010/04/serializing-and-deserializing-objects-with-ruby/

6. http://www.codeproject.com/Articles/33296/Serialization-and-De-serialization

7. http://www.ruby-doc.org/core-2.0.0/Marshal.html

8. http://www.waset.org/journals/waset/v60/v60-39.pdf

9. http://msdn.microsoft.com/en-us/library/182eeyhh.aspx

10.http://www.tutorialspoint.com/java/java_serialization.htm

11.http://www.codeproject.com/Articles/20962/Introducing-Serialization-in-NET

12. http://json.org

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T07:37:56Z

Tmuthuk:

== '''Serialization''' ==

'''Serialization'''[http://en.wikipedia.org/wiki/Serialization] is the process of converting an object or a group of objects into a stream of bytes or string to facilitate storage in memory or transmission over a network. The process of Serialization is also referred to as ''Marshalling''. The stream of data has to be in a format that can be understood by both ends of a communication channel so that the object can be marshaled and reconstructed easily.

'''Basic Advantages of Serialization''':

1.Facilitates the easy transportation of an object through a network.

2.Creates a clone of the object at the receiving end.

3.Ability to transmit data across the network in a cross-platform-compatible format.

4.Saving the data in a persistent or non-persistent storage medium in a non-proprietary format.

'''De-serialization''' is the process of converting the stream of bytes or string back to objects in memory. It is the process of reconstructing the object later.This process of de-serialization is also referred to as ''Unmarshalling''.

[[File:SerializationChart.jpg]]

== '''Serialization in Ruby:''' ==

Let us consider a situation where two Ruby programs have to communicate with each other. One of the simplest way to do this is to convert the Ruby objects in the first programs into strings and writing these strings into a file. This is nothing but serialization. The second program can read this file and convert the strings back into Ruby objects. This is de-serialization.

[[File:Types.jpg]]

== '''Types of Serialization''' ==

Serialization in Ruby can be done in two ways. During serialization, the object in memory can be converted into Human Readable formats like YAML (YAML Ain’t Markup Language) and JSON (JavaScript Object Notation), or the object can be converted into binary format.

=== Converting Ruby Objects in Human Readable Formats ===

==== Converting Ruby Objects to YAML format ====

YAML[http://yaml.org/] format is a human friendly data serialization standard for all programming languages. Any Ruby object can easily be serialized into YAML format. Let us consider the below code,

<code>require "yaml"</code>
<nowiki>class First
def initialize(name, age, country)
@name = name
@age = age
@country=country
end

def to_s
"In First:\n#{@name}, #{@age}, #{@country}\n"
end
end

class Second
def initialize(address, details)
@address = address
@details = details
end

def to_s
"In Second:\n#{@details.to_s}#{@address}\n"
end
end

x = First.new("Tom", 25, "USA")
y = Second.new("St. Marks Street", x)
puts y</nowiki>

We get the string representation of the object tree as the Output (because we have used the function to_s[http://ruby-doc.org/core-2.0.0/Object.html#method-i-to_s]).

'''Output''':

<code>
In Second:
In First:
Tom, 25, USA
St. Marks Street</code>

We use the below code to serialize out object tree.

<code>serialized_object = YAML::dump(y)
puts serialized_object</code>

The dump function serializes the object tree and stores the data in the YAML format in the variable serialized_object.

Data in the serialized (YAML) format looks like this:

<code>
--- !ruby/object:Second
address: St. Marks Street
details: !ruby/object:First
name: Tom
age: 25
country: USA</code>

Now, to de-serialize the data, we use load function.

<code>puts YAML::load(serialized_object)</code>

The data is converted back to Ruby object tree.

'''Output:'''

<code>In Second:
In First:
Tom, 25, USA
St. Marks Street
</code>

Thus we get back our original Object tree.

==== Converting Ruby Objects to JSON format: ====

JSON[http://www.json.org/] is a light-weight data interchange format. Any Ruby object can easily be serialized into JSON format.
The JSON library can be installed using Ruby Gems[http://rubygems.org/] like shown below:

<code># gem install json</code>

We can create a JSON string for serialization by using the JSON.generate method as below:

<code>
require 'json'
my_hash = {:Welcome => "Ruby"}
puts JSON.generate(my_hash) => "{\"WELCOME\":\"RUBY\"}"</code>

'''Output:'''

<code>{"{\"Welcome\":\"Ruby\"}"=>"{\"WELCOME\":\"RUBY\"}"}</code>

We can parse the JSON string received from another program by using JSON.parse
Ruby thus converts String to Hash.

<code>require 'json'
my_hash = JSON.parse('{"Welcome": "Ruby"}')
puts my_hash["Welcome"] => "Ruby"</code>

=== Converting Ruby Objects to Binary Formats ===
Binary Serialization is another form of serialization in Ruby which is not in human readable form. It is similar to YAML Serialization. Binary Serialization is done using Marshal[http://www.ruby-doc.org/core-2.0.0/Marshal.html]. Binary Serialization is used when high performance serialization and de-serialization process is required and when the contents are not required to be in readable format.

Since the Binary Serialized data is not in human readable form, there are two essential guidelines that need to be followed. They are :
1.Use print[http://ruby-doc.org/core-2.0.0/ARGF.html#method-i-print] instead of puts[http://ruby-doc.org/core-2.0.0/ARGF.html#method-i-puts] when serialized objects are written to a file in order to avoid new line characters to be written in the
file.

2.Use a record separator in order to differentiate between two objects.
<code>Binary Serialization Example </code>

<code>
class Animal
def initialize name, age
@name = name
@age=age
puts "#{self.class.name}"
end
end
class Cat < Animal
def to_s
"In Cat C: #{@name} \t #{@age}"
end
end
class Dog < Animal
def to_s
puts "In Dog D: #{@name} \t #{@age}"
end
end
d = Dog.new("Doggy Dig", 4)
c = Cat.new("Kitty Kat",5)
puts "Before Serialization"
puts c
puts d
serialize_cat= Marshal.dump(c)
serialize_dog= Marshal.dump(d)
deserialize_cat= Marshal::load(serialize_cat)
deserialize_dog= Marshal::load(serialize_dog)
puts "After Serialization #{deserialize_cat}"
puts "After Dog Serialization #{deserialize_dog}"
</code>

Output
<code>
Before Serialization
In Cat C: Kitty Kat 5
In Dog D: Doggy Dig 4
After Serialization In Cat C: Kitty Kat 5
After Dog Serialization In Dog D: Doggy Dig 4
</code>

== Serialization in OOLS Languages: Comparison ==
{| class="wikitable"
|-
! Sr.No !! Ruby !! Java !! .Net Framework
|-
| 1 || Ruby provides a module called ‘Marshal'[http://www.ruby-doc.org/core-2.0.0/Marshal.html] for serialization || Java uses an Interface named ‘Serializable’[http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html] interface for classes to implement || .Net provides a ‘Serializable’[http://msdn.microsoft.com/en-us/library/ms973893.aspx] Attribute
|-
| 2 || Ruby uses JSON to make it platform independent || An object can be serialized in one platform and de-serialized in another platform || .Net used Remoting technology to make it platform independent.
|-
| 3 || Ruby serializes an Object as a whole.|| Provides an option for serializing only the required methods/attributes to be serialized for an object. Use the keyword ‘Transient’ to ignore certain methods that doesn’t need to be serialized || XML Serializer[http://msdn.microsoft.com/en-us/library/ms973893.aspx] will not serialize not convert methods, indexers, private fields, or read-only properties.
|}
== References ==
1. http://wikipedia.org

2. http://yaml.org

3. http://www.ruby-doc.org

4. http://www.w3schools.com

5. http://www.skorks.com/2010/04/serializing-and-deserializing-objects-with-ruby/

6. http://www.codeproject.com/Articles/33296/Serialization-and-De-serialization

7. http://www.ruby-doc.org/core-2.0.0/Marshal.html

8. http://www.waset.org/journals/waset/v60/v60-39.pdf

9. http://msdn.microsoft.com/en-us/library/182eeyhh.aspx

10.http://www.tutorialspoint.com/java/java_serialization.htm

11.http://www.codeproject.com/Articles/20962/Introducing-Serialization-in-NET

12. http://json.org

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T07:11:50Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:58:21Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:57:07Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:56:43Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:55:47Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:54:21Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:53:43Z

Tmuthuk:

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:52:40Z

Tmuthuk: /* Converting Ruby Objects to Binary Formats */

CSC/ECE 517 Fall 2013/ch1 1w05 st

2013-09-18T06:50:36Z

Tmuthuk: