\documentclass[11pt,twoside]{article}\makeatletter

\IfFileExists{xcolor.sty}%
  {\RequirePackage{xcolor}}%
  {\RequirePackage{color}}
\usepackage{colortbl}
\usepackage{wrapfig}
\usepackage{ifxetex}
\ifxetex
  \usepackage{fontspec}
  \usepackage{xunicode}
  \catcode`⃥=\active \def⃥{\textbackslash}
  \catcode`❴=\active \def❴{\{}
  \catcode`❵=\active \def❵{\}}
  \def\textJapanese{\fontspec{Noto Sans CJK JP}}
  \def\textChinese{\fontspec{Noto Sans CJK SC}}
  \def\textKorean{\fontspec{Noto Sans CJK KR}}
  \setmonofont{DejaVu Sans Mono}
  
\else
  \IfFileExists{utf8x.def}%
   {\usepackage[utf8x]{inputenc}
      \PrerenderUnicode{–}
    }%
   {\usepackage[utf8]{inputenc}}
  \usepackage[english]{babel}
  \usepackage[T1]{fontenc}
  \usepackage{float}
  \usepackage[]{ucs}
  \uc@dclc{8421}{default}{\textbackslash }
  \uc@dclc{10100}{default}{\{}
  \uc@dclc{10101}{default}{\}}
  \uc@dclc{8491}{default}{\AA{}}
  \uc@dclc{8239}{default}{\,}
  \uc@dclc{20154}{default}{ }
  \uc@dclc{10148}{default}{>}
  \def\textschwa{\rotatebox{-90}{e}}
  \def\textJapanese{}
  \def\textChinese{}
  \IfFileExists{tipa.sty}{\usepackage{tipa}}{}
\fi
\def\exampleFont{\ttfamily\small}
\DeclareTextSymbol{\textpi}{OML}{25}
\usepackage{relsize}
\RequirePackage{array}
\def\@testpach{\@chclass
 \ifnum \@lastchclass=6 \@ne \@chnum \@ne \else
  \ifnum \@lastchclass=7 5 \else
   \ifnum \@lastchclass=8 \tw@ \else
    \ifnum \@lastchclass=9 \thr@@
   \else \z@
   \ifnum \@lastchclass = 10 \else
   \edef\@nextchar{\expandafter\string\@nextchar}%
   \@chnum
   \if \@nextchar c\z@ \else
    \if \@nextchar l\@ne \else
     \if \@nextchar r\tw@ \else
   \z@ \@chclass
   \if\@nextchar |\@ne \else
    \if \@nextchar !6 \else
     \if \@nextchar @7 \else
      \if \@nextchar (8 \else
       \if \@nextchar )9 \else
  10
  \@chnum
  \if \@nextchar m\thr@@\else
   \if \@nextchar p4 \else
    \if \@nextchar b5 \else
   \z@ \@chclass \z@ \@preamerr \z@ \fi \fi \fi \fi
   \fi \fi  \fi  \fi  \fi  \fi  \fi \fi \fi \fi \fi \fi}
\gdef\arraybackslash{\let\\=\@arraycr}
\def\@textsubscript#1{{\m@th\ensuremath{_{\mbox{\fontsize\sf@size\z@#1}}}}}
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\def\abbr{}
\def\corr{}
\def\expan{}
\def\gap{}
\def\orig{}
\def\reg{}
\def\ref{}
\def\sic{}
\def\persName{}\def\name{}
\def\placeName{}
\def\orgName{}
\def\textcal#1{{\fontspec{Lucida Calligraphy}#1}}
\def\textgothic#1{{\fontspec{Lucida Blackletter}#1}}
\def\textlarge#1{{\large #1}}
\def\textoverbar#1{\ensuremath{\overline{#1}}}
\def\textquoted#1{‘#1’}
\def\textsmall#1{{\small #1}}
\def\textsubscript#1{\@textsubscript{\selectfont#1}}
\def\textxi{\ensuremath{\xi}}
\def\titlem{\itshape}
\newenvironment{biblfree}{}{\ifvmode\par\fi }
\newenvironment{bibl}{}{}
\newenvironment{byline}{\vskip6pt\itshape\fontsize{16pt}{18pt}\selectfont}{\par }
\newenvironment{citbibl}{}{\ifvmode\par\fi }
\newenvironment{docAuthor}{\ifvmode\vskip4pt\fontsize{16pt}{18pt}\selectfont\fi\itshape}{\ifvmode\par\fi }
\newenvironment{docDate}{}{\ifvmode\par\fi }
\newenvironment{docImprint}{\vskip 6pt}{\ifvmode\par\fi }
\newenvironment{docTitle}{\vskip6pt\bfseries\fontsize{22pt}{25pt}\selectfont}{\par }
\newenvironment{msHead}{\vskip 6pt}{\par}
\newenvironment{msItem}{\vskip 6pt}{\par}
\newenvironment{rubric}{}{}
\newenvironment{titlePart}{}{\par }

\newcolumntype{L}[1]{){\raggedright\arraybackslash}p{#1}}
\newcolumntype{C}[1]{){\centering\arraybackslash}p{#1}}
\newcolumntype{R}[1]{){\raggedleft\arraybackslash}p{#1}}
\newcolumntype{P}[1]{){\arraybackslash}p{#1}}
\newcolumntype{B}[1]{){\arraybackslash}b{#1}}
\newcolumntype{M}[1]{){\arraybackslash}m{#1}}
\definecolor{label}{gray}{0.75}
\def\unusedattribute#1{\sout{\textcolor{label}{#1}}}
\DeclareRobustCommand*{\xref}{\hyper@normalise\xref@}
\def\xref@#1#2{\hyper@linkurl{#2}{#1}}
\begingroup
\catcode`\_=\active
\gdef_#1{\ensuremath{\sb{\mathrm{#1}}}}
\endgroup
\mathcode`\_=\string"8000
\catcode`\_=12\relax

\usepackage[a4paper,twoside,lmargin=1in,rmargin=1in,tmargin=1in,bmargin=1in,marginparwidth=0.75in]{geometry}
\usepackage{framed}

\definecolor{shadecolor}{gray}{0.95}
\usepackage{longtable}
\usepackage[normalem]{ulem}
\usepackage{fancyvrb}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{marginnote}

\renewcommand{\@cite}[1]{#1}


\renewcommand*{\marginfont}{\itshape\footnotesize}

\def\Gin@extensions{.pdf,.png,.jpg,.mps,.tif}

  \pagestyle{fancy}

\usepackage[pdftitle={Object Serialization Formats and Techniques a Review},
 pdfauthor={}]{hyperref}
\hyperbaseurl{}

	 \paperwidth210mm
	 \paperheight297mm
              
\def\@pnumwidth{1.55em}
\def\@tocrmarg {2.55em}
\def\@dotsep{4.5}
\setcounter{tocdepth}{3}
\clubpenalty=8000
\emergencystretch 3em
\hbadness=4000
\hyphenpenalty=400
\pretolerance=750
\tolerance=2000
\vbadness=4000
\widowpenalty=10000

\renewcommand\section{\@startsection {section}{1}{\z@}%
     {-1.75ex \@plus -0.5ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large\bfseries}}
\renewcommand\subsection{\@startsection{subsection}{2}{\z@}%
     {-1.75ex\@plus -0.5ex \@minus- .2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\Large}}
\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
     {-1.5ex\@plus -0.35ex \@minus -.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\large}}
\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
     {-1ex \@plus-0.35ex \@minus -0.2ex}%
     {0.5ex \@plus .2ex}%
     {\reset@font\normalsize}}
\renewcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
     {1.5ex \@plus1ex \@minus .2ex}%
     {-1em}%
     {\reset@font\normalsize\bfseries}}


\def\l@section#1#2{\addpenalty{\@secpenalty} \addvspace{1.0em plus 1pt}
 \@tempdima 1.5em \begingroup
 \parindent \z@ \rightskip \@pnumwidth 
 \parfillskip -\@pnumwidth 
 \bfseries \leavevmode #1\hfil \hbox to\@pnumwidth{\hss #2}\par
 \endgroup}
\def\l@subsection{\@dottedtocline{2}{1.5em}{2.3em}}
\def\l@subsubsection{\@dottedtocline{3}{3.8em}{3.2em}}
\def\l@paragraph{\@dottedtocline{4}{7.0em}{4.1em}}
\def\l@subparagraph{\@dottedtocline{5}{10em}{5em}}
\@ifundefined{c@section}{\newcounter{section}}{}
\@ifundefined{c@chapter}{\newcounter{chapter}}{}
\newif\if@mainmatter 
\@mainmattertrue
\def\chaptername{Chapter}
\def\frontmatter{%
  \pagenumbering{roman}
  \def\thechapter{\@roman\c@chapter}
  \def\theHchapter{\roman{chapter}}
  \def\thesection{\@roman\c@section}
  \def\theHsection{\roman{section}}
  \def\@chapapp{}%
}
\def\mainmatter{%
  \cleardoublepage
  \def\thechapter{\@arabic\c@chapter}
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \pagenumbering{arabic}
  \setcounter{secnumdepth}{6}
  \def\@chapapp{\chaptername}%
  \def\theHchapter{\arabic{chapter}}
  \def\thesection{\@arabic\c@section}
  \def\theHsection{\arabic{section}}
}
\def\backmatter{%
  \cleardoublepage
  \setcounter{chapter}{0}
  \setcounter{section}{0}
  \setcounter{secnumdepth}{2}
  \def\@chapapp{\appendixname}%
  \def\thechapter{\@Alph\c@chapter}
  \def\theHchapter{\Alph{chapter}}
  \appendix
}
\newenvironment{bibitemlist}[1]{%
   \list{\@biblabel{\@arabic\c@enumiv}}%
       {\settowidth\labelwidth{\@biblabel{#1}}%
        \leftmargin\labelwidth
        \advance\leftmargin\labelsep
        \@openbib@code
        \usecounter{enumiv}%
        \let\p@enumiv\@empty
        \renewcommand\theenumiv{\@arabic\c@enumiv}%
	}%
  \sloppy
  \clubpenalty4000
  \@clubpenalty \clubpenalty
  \widowpenalty4000%
  \sfcode`\.\@m}%
  {\def\@noitemerr
    {\@latex@warning{Empty `bibitemlist' environment}}%
    \endlist}

\def\tableofcontents{\section*{\contentsname}\@starttoc{toc}}
\parskip0pt
\parindent1em
\def\Panel#1#2#3#4{\multicolumn{#3}{){\columncolor{#2}}#4}{#1}}
\newenvironment{reflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemsep}{0pt}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\itshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{sansreflist}{%
  \begin{raggedright}\begin{list}{}
  {%
   \setlength{\topsep}{0pt}%
   \setlength{\rightmargin}{0.25in}%
   \setlength{\itemindent}{0pt}%
   \setlength{\parskip}{0pt}%
   \setlength{\itemsep}{0pt}%
   \setlength{\parsep}{2pt}%
   \def\makelabel##1{\upshape ##1}}%
  }
  {\end{list}\end{raggedright}}
\newenvironment{specHead}[2]%
 {\vspace{20pt}\hrule\vspace{10pt}%
  \phantomsection\label{#1}\markright{#2}%

  \pdfbookmark[2]{#2}{#1}%
  \hspace{-0.75in}{\bfseries\fontsize{16pt}{18pt}\selectfont#2}%
  }{}
      \def\TheFullDate{2013-01-15 (revised: 15 January 2013)}
\def\TheID{\makeatother }
\def\TheDate{2013-01-15}
\title{Object Serialization Formats and Techniques a Review}
\author{}\makeatletter 
\makeatletter
\newcommand*{\cleartoleftpage}{%
  \clearpage
    \if@twoside
    \ifodd\c@page
      \hbox{}\newpage
      \if@twocolumn
        \hbox{}\newpage
      \fi
    \fi
  \fi
}
\makeatother
\makeatletter
\thispagestyle{empty}
\markright{\@title}\markboth{\@title}{\@author}
\renewcommand\small{\@setfontsize\small{9pt}{11pt}\abovedisplayskip 8.5\p@ plus3\p@ minus4\p@
\belowdisplayskip \abovedisplayskip
\abovedisplayshortskip \z@ plus2\p@
\belowdisplayshortskip 4\p@ plus2\p@ minus2\p@
\def\@listi{\leftmargin\leftmargini
               \topsep 2\p@ plus1\p@ minus1\p@
               \parsep 2\p@ plus\p@ minus\p@
               \itemsep 1pt}
}
\makeatother
\fvset{frame=single,numberblanklines=false,xleftmargin=5mm,xrightmargin=5mm}
\fancyhf{} 
\setlength{\headheight}{14pt}
\fancyhead[LE]{\bfseries\leftmark} 
\fancyhead[RO]{\bfseries\rightmark} 
\fancyfoot[RO]{}
\fancyfoot[CO]{\thepage}
\fancyfoot[LO]{\TheID}
\fancyfoot[LE]{}
\fancyfoot[CE]{\thepage}
\fancyfoot[RE]{\TheID}
\hypersetup{citebordercolor=0.75 0.75 0.75,linkbordercolor=0.75 0.75 0.75,urlbordercolor=0.75 0.75 0.75,bookmarksnumbered=true}
\fancypagestyle{plain}{\fancyhead{}\renewcommand{\headrulewidth}{0pt}}

\date{}
\usepackage{authblk}

\providecommand{\keywords}[1]
{
\footnotesize
  \textbf{\textit{Index terms---}} #1
}

\usepackage{graphicx,xcolor}
\definecolor{GJBlue}{HTML}{273B81}
\definecolor{GJLightBlue}{HTML}{0A9DD9}
\definecolor{GJMediumGrey}{HTML}{6D6E70}
\definecolor{GJLightGrey}{HTML}{929497} 

\renewenvironment{abstract}{%
   \setlength{\parindent}{0pt}\raggedright
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
   \textcolor{GJBlue}{\large\bfseries\abstractname\space}
}{%   
   \vskip8pt
   \textcolor{GJMediumGrey}{\rule{\textwidth}{2pt}}
   \vskip16pt
}

\usepackage[absolute,overlay]{textpos}

\makeatother 
      \usepackage{lineno}
      \linenumbers
      
\begin{document}

             \author[1]{  Surbhi}

             \author[2]{Rama  Chawla}

             \affil[1]{  Kurukshetra University}

\renewcommand\Authands{ and }

\date{\small \em Received: 8 December 2012 Accepted: 2 January 2013 Published: 15 January 2013}

\maketitle


\begin{abstract}
        


Serialization is a process of converting an object into a stream of data so that it can be easily transmittable over the network or can be continued in a persistent storage location. This storage location can be a physical file, database or Network Stream. This paper concludes some the work that is going on in the field of Object Serialization.This paper presents Object Serialization Techniques that can be useful for various purposes, including object serialization Minimization which can be used to decrease the size of Serialized data.

\end{abstract}


\keywords{object serialization, compression techniques, object oriented design, performance analytics, soap.}

\begin{textblock*}{18cm}(1cm,1cm) % {block width} (coords) 
\textcolor{GJBlue}{\LARGE Global Journals \LaTeX\ JournalKaleidoscope\texttrademark}
\end{textblock*}

\begin{textblock*}{18cm}(1.4cm,1.5cm) % {block width} (coords) 
\textcolor{GJBlue}{\footnotesize \\ Artificial Intelligence formulated this projection for compatibility purposes from the original article published at Global Journals. However, this technology is currently in beta. \emph{Therefore, kindly ignore odd layouts, missed formulae, text, tables, or figures.}}
\end{textblock*}


\let\tabcellsep& 	 	 		 
\section[{Introduction}]{Introduction}\par
erialization is the process of converting complex objects into stream of bytes for storage. Deserialization is its reverse process that is unpacking stream of bytes to their original form. It is also known as Pickling, the process of creating a serialized representation of object.\par
The following steps are necessary to do to create a serializable class: 1. Create a custom class with assigned properties. 2. Define the serialization functions. 3. Create a Controller class and instantiate our Custom class. 4. Serialize the object to a named file. 5. De-serialize the values by reading it from the file.\par
Object serialization has been investigated for many years in the context of many different distributed systems. 
\section[{II. Most Popular Serialization Formats}]{II. Most Popular Serialization Formats}\par
There are various data serialization formats available for developers according to choose form, There are also various ways to convert complex objects to sequences of bits. It does not include markup languages used exclusively as document file formats.\par
? Binary Format Serialization ? XML Format Serialization ? XML-RPC Serialization \hyperref[b0]{[1]} ? JSON Serialization \hyperref[b1]{[2]} ? YAML[C] Serialization\par
The following are the basic advantages of serialization: First is to facilitate the transportation of an object through a network and secondly create a clone of an object that can be restored later on. 
\section[{III.}]{III.} 
\section[{Related Work}]{Related Work}\par
In the paper "Object Serialization and Deserialization Using XML \hyperref[b2]{[3]} " Inter operability of potentially heterogeneous databases has been an ongoing research issue for a number of years in the database community.\par
With the trend towards globalization of data location and data access and the consequent requirement for the coexistence of new data stores with legacy systems, the cooperation and data interchange between data repositories has become increasingly important. The emergence of the extensible Markup Language (XML) as a database independent representation for data offers a suitable mechanism for transporting data between repositories.\par
This paper describes a research activity within a group at CERN (called CMS) towards identifying and implementing database serialization and deserialization methods that can be used to replicate or migrate objects across the network between CERN and worldwide centers using XML to serialize the contents of multiple objects resident in object oriented databases.\par
The paper "Generic Pickling and Minimization [4]   " presents generic pickling and minimization mechanisms that are provided as services similar to garbage collection. Pickling is used to externalize and internalize data. Minimization means to maximize the sharing in arbitrary data structures. The paper introduces the notion of an abstract store as a formal basis for the algorithms, and analyzes design decisions for the implementation aspects of pickling and minimization. The mechanisms presented here are fully implemented in the Alice programming system.\par
We presented a generic pickling and minimization mechanism. We showed how Alice, as a conservative extension of Standard ML, uses pickling in a type safe way for its component system. To build a formal base for the algorithms, we introduced abstract stores as a universal memory model. Un-pickling and pickling are based on this model, allowing us to analyze( D D D D D D D D )\par
and evaluate our design decisions such as bottom up versus top down un-pickling and right to left versus left to right traversal. Minimization can be used to decrease the size of pickled data. However, the general mechanism presented here seems suitable for other applications such as efficient representation of runtime types. Finally, we extended the system with support for concurrency as present in Alice. The authors analyzed how pickler and minimizer must behave in such a concurrent setting.\par
In the paper "Why Object Serialization is Inappropriate for Providing Persistence in Java" \hyperref[b4]{[5]} the author paper describes why Object Serialization is not appropriate for providing persistence in Java. With numerous code examples, Object Serialization is shown to be easy to work with initially which seduces the developer into relying on it for persistence within more complex applications.\par
The advanced use of object serialization requires significant work from the programmer, something that is not apparent at first. The use of object serialization together with static and transient fields and within multithreaded programs is discussed together with the "big inhale problem": the need to read in the entire object graph before processing over it can commence.\par
This paper has shown, with numerous supporting examples, that using Java's object serialization mechanism to provide object persistence is inappropriate. The system appears simple on the surface but there are many implications from relying on it as a persistence technology. The programmer must state the types that are candidates for persistence at compile time, whereas making this decision at runtime, on a per object basis, is more appropriate.\par
The serialization mechanism suffers from the big inhale problem where the whole graph must be read before it can be used; loading objects on demand is more efficient, reducing delay in starting an application. The serialization mechanism creates copies of objects that it writes and reads. This can break some code that makes assumptions about the hash code of an object.\par
Figure  {\ref 1} : Object serialization for various type of objects with encodings \hyperref[b4]{[5]} The complexity of using object serialization within 1a distributed environment, when evolving classes and when using specialized class loaders is also discussed. The paper compares performance of serializing and de-serializing a byte array and binary tree of the same data size to and from an NFS mounted disk and two kinds of local disk. Alternative solutions to object persistence in Java are presented at the end of the paper.\par
Using Experiments carried out by author to draws four conclusions:\par
1. The absolute amount of time to read and write a store is large; 2. Reading a store is much slower than writing a store;\par
and if an application is likely to exhibit more reading than writing, 3. An NFS mounted disk should be used; 4. The use of JIT technology significantly increases the speed of using Java object serialization.\par
In the "Object Serialization in the .NET Framework" \hyperref[b5]{[6]} , the author describes using Serialization in .Net framework. He describes the two most important reasons are to persist the state of an object to a storage medium so an exact copy can be recreated at a later stage, and to send the object by value from one application domain to another.\par
It is also used by remoting to pass objects by value from one application domain to another. This paper provides an overview of the serialization used in the Microsoft .NET Framework.\par
The author gives Serialization Guidelines, one should consider serialization when designing new classes since a class cannot be made serializable after it has been compiled. Some questions to ask are: Do one have to send this class across application domains? Will this class ever be used with remoting? What will users do with this class? Maybe they derive a new class that needs to be serialized. When in doubt, mark the class as serializable. It is probably better to mark all classes as serializable unless:\par
? They will never cross an application domain. "Comparison between JSON and YAML for data serialization" \hyperref[b6]{[7]} , this report determines and discusses the primary differences between two different serialization formats, namely YAML and JSON. A general introduction to the concepts of serialization and parsing is provided first, which also explains how they can be used to transfer and store data. This is followed by an analysis of the YAML and JSON formats, where functionality, primary use cases, and syntax is described. In addition to this the percieved performance of implementations for both formats will also be investigated by conducting a number of tests.\par
Using the combined background information and results from the tests, conclusions regarding the main differences between the two are then determined and discussed.\par
As has been concluded, it is clearly very easy to read thanks to the required usage of whitespace and the ability to skip surrounding quotes for strings. YAML also has the advantage of allowing comments in the document. Users can easily read and manipulate the output, which is one of the reasons as to why it's often used for configuration files.\par
This enables the straightforward definition of strongly-typed objects that match serialized structures, for example existing XML formats. Inheritable translation scopes group sets of object serialization binding definitions, and enable inheritance. The present system supports (compressed) XML for serialization, while future work will develop alternate translation schemes, such as type-length-value and JSON. Execution times in seconds for Seriali-zation Execution times in seconds for De-Serialization Table  {\ref 2} : JSON VS. YAML Serialization performance \hyperref[b6]{[7]} The execution times measured for the serialization/deserialization process shows their results, similar to the serialization process, which can be seen in table  {\ref 2}. Both implementations are much faster at generating data structures from a serialized string than doing the opposite. YAML is also slower. 
\section[{IV.}]{IV.} 
\section[{Conclusion}]{Conclusion}\par
The primary design goals for Serialization, to provide a simple and effective data exchange, but also being easy to generate and load. It is widely used and is used natively available in the most common modern programming. Object Serialization as presented here is especially well suited for functional programming languages, where the closure semantics and the ability to serialize code is essential. Also a minimization technique helps reduce Serialization sizes considerably.\par
V. 
\section[{Future Scope}]{Future Scope}\par
To implement means by which Serialization and Deserialization of Objects can be done using modern formats XML and JSON after adding Compression or Encryption or possibly both to the Object Streams.\par
In future I also want to see how the Performance of Object Serialization is affected in a Normal CLR Binary VS. Native JIT compiled Binary. The perceived performance of XML or JSON can be determined from a custom benchmarking. A complex data set will also be used to test performance of the implementations for documents with deeper hierarchies.\par
Another direction for future work may be to modify the semantics of the serialization algorithm to improve performance. \begin{figure}[htbp]
\noindent\textbf{}\includegraphics[]{image-2.png}
\caption{\label{fig_0}}\end{figure}
 			\footnote{© 2013 Global Journals Inc. (US) Global Journal of Computer Science and Technology} 			\footnote{© 2013 Global Journals Inc. (US)} 		 		\backmatter  			  				\begin{bibitemlist}{1}
\bibitem[Sumaray and Makki ()]{b1}\label{b1} 	 		‘A comparison of data serialization formats for optimal efficiency on a mobile platform’.  		 			Audie Sumaray 		,  		 			S Kami Makki 		.  	 	 		\textit{Proceedings of the 6th International Conference on Ubiquitous Information Management and Communication},  				 (the 6th International Conference on Ubiquitous Information Management and CommunicationNew York, NY, USA, Article)  		2012. ACM. p. 48.  	 
\bibitem[Imre ()]{b3}\label{b3} 	 		‘A Novel Cost Model of XML Serialization’.  		 			G Imre 		.  	 	 		\textit{Science Direct, Electronic Notes in Theoretical Computer Science}  		2010. 261.  		 			Department of Automation and Applied Informatics, Budapest University of Technology and Economics 		 	 
\bibitem[Allman (2003)]{b0}\label{b0} 	 		‘An evaluation of XML-RPC. SIGMETRICS Perform’.  		 			Mark Allman 		.  	 	 		\textit{Eval. Rev}  		2003. March 2003. 30  (4)  p. .  	 
\bibitem[Eriksson and Hallberg ()]{b6}\label{b6} 	 		\textit{Comparison between JSON and YAML for data serialization},  		 			Malin Eriksson 		,  		 			Victor Hallberg 		.  		2011.  		 			Computer Science and Engineering Royal Institute of Technology 		 	 
\bibitem[Opyrchal and Prakash]{b8}\label{b8} 	 		\textit{Efficient Object Serialization in Java},  		 			Lukasz Opyrchal 		,  		 			Atul Prakash 		.  		Ann Arbor, MI; USA. p. .  		 			Department of Electrical Engineering and Computer Science, University of Michigan 		 	 
\bibitem[Tack and Kornstaedt ()]{b4}\label{b4} 	 		‘Generic Pickling and Minimization’.  		 			Guido Tack 		,  		 			Leif Kornstaedt 		.  	 	 		\textit{Science Direct, Electronic Notes in Theoretical Computer Science}  		2006.  		 			Programming Systems Lab Saarland University 		 	 
\bibitem[Bhatti and Hassan ()]{b2}\label{b2} 	 		‘Object Serialization and Deserialization Using XML’.  		 			N Bhatti 		,  		 			\& W Hassan 		.  	 	 		\textit{ADVANCES IN DATA MANAGEMENT}  		2000. 1.  	 
\bibitem[Obermeyer and Hawkins ()]{b7}\label{b7} 	 		‘Object Serialization in the .NET Framework’.  		 			Piet Obermeyer 		,  		 			Jonathan Hawkins 		.  	 	 		\textit{Microsoft Corporation},  				2001.  	 
\bibitem[Evans]{b5}\label{b5} 	 		\textit{Why Object Serialization is Inappropriate for Providing Persistence in Java},  		 			Huw Evans 		.  		Glasgow, G12 8RZ, UK.  		 			Department of Computing Science, The University of Glasgow 		 	 
\end{bibitemlist}
 			 		 	 
\end{document}