Analyzing and Comparing the Parsing Techniques of Asynchronous Message

Document Sample
Analyzing and Comparing the Parsing Techniques of Asynchronous Message Powered By Docstoc
					                                                    (IJCSIS) International Journal of Computer Science and Information Security,
                                                                                                        Vol. 9, No. 5, May 2011

                  Analyzing and Comparing the Parsing
                  Techniques of Asynchronous Message
                       Mr.P.Krishna Sankar,                                        Ms.N.P.Shangaranarayanee
                      Assistant Professor,                                                 Student,
                                                                        Department of Computer science and Engineering,
        Department of Computer science and Engineering,
                                                                         Angel College of Engineering and Technology,
           Dr.Mahalingam College of Engineering &                             Tirupur-641 665, Tamilnadu, India.
        Technology, Pollachi – 642 003, Tamilnadu, India.
                                                                                   npsnarayanee@gmail.com
                     pksankar@gmail.com

Abstract— Java API for XML Processing (JAXP) provided                   bottlenecks in applications and systems that process large
two methods for processing XML: Document Object Model                   volumes of XML data [3].
(DOM) and Simple API for XML (SAX). The idea is to parse
the whole document and construct a complete document tree                   XML processing can incur significant run-time
in memory before it returns control to the client. This cannot          overhead in XML-based infra structural middleware such as
be achieved through either by DOM nor by SAX. So StAX is                Web service application servers [4]. XML document is the
introduced to achieve the idea. StAX does not suffer from the           general tree structure and the XML processing task as the
drawbacks faced while using DOM and SAX. A parser is a                  extension from the parallel tree traversal algorithm for the
computer program or a component of a program that                       classic discrete optimization problems. Analyse the standard
analyses the grammatical structure of an input with respect to          parsing techniques like JDOM, SAX and STAX, based on
a given formal grammar in a process known as parsing.                   that efficiency of different parsers is computed.
Typically, a parser transforms some input text into a data
structure that can be processed easily, e.g. for semantic                   Java API for XML Processing (JAXP) provided two
checking, code generation or to help understanding the input.           methods for processing XML - the Document Object Model
Such data structure usually captures the implied hierarchy of           (DOM) method, which uses a standard object model to
the input and forms a tree or even a graph. XML document as             represent XML documents, and the Simple API for XML
general tree structure and processing task as the extension             (SAX) method, which uses application-supplied event
from the parallel tree traversal algorithm for the classic              handlers to process XML. Processing several XML
discrete optimization problems. Unlike the Simple API for               documents simultaneously can be a significant challenge
XML (SAX), StAX offers an API for writing XML                           [2]. We are using the Java to develop the parser like JDOM,
documents. To be precise, it offers two APIs: a low-level,              SAX, STAX and open source software. SAX parsers, for
cursor-based API (XMLStreamWriter), and a higher-level,                 example, deliver the parsing events through callbacks to the
event-based API (XMLEventWriter). While the cursor-based                client application. Because the SAX parser controls this
API is best used in data binding scenarios (for example,                process, the client application does not really have a chance
creating a document from application data), the event-based             to synchronize the different input sources. Therefore,
API is typically used in pipelining scenarios where a new               programmers usually resort to the DOM parser when it
document is constructed from the data of input documents.
                                                                        comes to multi-document processing. However, the penalty
   Keywords— DOM, SAX, StAX, API, XML                                   here is excessive resource usage; the node trees of all input
                                                                        documents must completely reside in memory.
                    I.INTRODUCTION
                                                                                        II. PARSING ANALYSIS
    XML stands for the Extensible Markup Language. It is a
Markup language for documents, Nowadays XML is a tool                       A parser is a computer program or a component of a
to develop and likely to become a much more common tool                 program that analyses the grammatical structure of an input
for sharing data and store. XML can communicate                         with respect to a given formal grammar in a process known
structured information to other users [1]. In other words, if a         as parsing. Typically, a parser transforms some input text
group of users agree to implement the same kinds of tags to             into a data structure that can be processed easily, e.g. for
describe a certain kind of information, XML applications                semantic checking, code generation or to help
can assist these users in communicating their information in            understanding the input.
an more robust and efficient manner. XML can make it                    A. JDOM
easier to exchange information between cooperating
                                                                           JDOM is a tree-based API for processing XML
entities. XML technique can be categorized by four factors
                                                                        documents with Java that threw out DOM’s limitations and
Strength of XML, XML Parser, XML Goals and Types of
                                                                        assumptions and started from scratch. It is designed purely
XML Parsers [5]. XML parsing is a core operation
                                                                        for XML, purely for Java, and with no concern for
performed on an XML document for it to be accessed and
                                                                        backwards compatibility with earlier, similar APIs. JDOM
manipulated. This operation is known to cause performance
                                                                        is written in and for Java. It consistently uses the Java




                                                                  7                             http://sites.google.com/site/ijcsis/
                                                                                                ISSN 1947-5500
                                                          (IJCSIS) International Journal of Computer Science and Information Security,
                                                                                                              Vol. 9, No. 5, May 2011
coding conventions and the class library. It is thus much            for an object, using polymorphism to match the method
cleaner and much simpler than DOM. Most developers find              name to the handler code, and using encapsulation to
JDOM to be far more intuitive and easy to use than DOM.              manage state in the handler between callbacks. This overall
It’s not that JDOM will enable you to do anything you can’t          model of event-based programming is known as a push
do with DOM. However, writing the same program with                  model and has a reputation for being difficult for many
JDOM will normally take you less time and have fewer                 programmers to master. Most models that are considered
bugs when finished, simply because of the greater                    easier to program, however, require random access to the
intuitiveness of the API. In many ways, JDOM is to DOM               document, and thus can lead to inefficiencies, so SAX has
as Java is to C++, a much improved, incompatible                     the reputation for being the most efficient standard way to
replacement for the earlier more complex technology.                 process XML, if far from the easiest.
JDOM is an open source, tree-based, pure Java API for
parsing, creating, manipulating, and serializing XML                 C. StAX
documents. JDOM was invented by Brett McLaughlin and                    Streaming API for XML (StAX) is an application
Jason Hunter in the spring of 2000.                                  programming interface (API) to read and write XML
                                                                     documents, originating from the Java programming
    JDOM can build a new XML tree in memory. Data for                language community. Traditionally, XML APIs are either:
the tree can come from a non-XML source like a database,
from literals in the Java program, or from calculations as in            Tree based - the entire document is read into memory
many of the Fibonacci number examples in this book. When                  as a tree structure for random access by the calling
creating new XML documents from scratch (rather than                      application
reading them from a parser), JDOM checks all the data for
well-formed. For example, unlike many DOM                                Event based - the application registers to receive events
implementations, JDOM does not allow programs to create                   as entities are encountered within the source document.
comments whose data includes the double hyphen -- or                     Streaming APIs for XML (StAX) which is a
elements and attributes whose namespace mapping conflict             standardized Java based API for pull-parsing XML. StAX
in impossible ways.                                                  has two basic functions: to allow users to read and write
   Once a document has been loaded into memory, whether              XML as efficiently as possible and be easy to use (cursor
by creating it from scratch or by parsing it from a stream,          API), and be easy to extend and allow for easy pipelining
JDOM can modify the document. A JDOM tree is fully                   (event iterator API). Pull parsing differs from the traditional
read-write. All parts of the tree can be moved, deleted, and         SAX based iteration and DOM based tree model, in that it is
added to, subject to the usual restrictions of XML.                  optimized for speed and performance. StAX is often
                                                                     referred to as “pull parsing.” The developer uses a simple
B. SAX                                                               iterator based API to “pull” the next XML construct in the
    SAX stands for Simple API for XML. SAX parsing is                document. However, the common streaming APIs like SAX
unidirectional; previously parsed data cannot be re-read             are all push APIs. They feed the content of the document to
without starting the parsing operation again. The SAX                the application as soon as they see it, whether the
standard currently is at version 2.0. It is used to read data        application is ready to receive that data or not. SAX and
from a XML document. A parser that uses SAX parses the               XNI are fast and efficient, but the patterns they require
XML serially. The API is event driven and these events are           programmers to adopt are unfamiliar and uncomfortable to
fired when the XML features are encountered. XML parsing             many developers.
is unidirectional. Memory used by a SAX parses is                        Pull APIs are a more comfortable alternative for
relatively low. Due to the event nature of SAX, the parsing          streaming processing of XML. A pull API is based around
is faster of an XML document. SAX usually follows Push-              the more familiar iterator design pattern rather than the less
based parsing, in which case, the Parser will scan the XML           well-known observer design pattern. In a pull API, the
Document from top to bottom and whenever it founds some              client program asks the parser for the next piece of
node (like start node, end node, text-node etc.) it will push        information rather than the parser telling the client program
notifications to the Application in the form of Events. So,          when the next datum is available. In a pull API the client
SAX is basically a sequential, event-based parser. SAX is a          program drives the parser. In a push API the parser drives
callback implementation. As it iterates over each                    the client.
fundamental unit of XML, is that as it reads each unit of
XML, it creates an event that the host program can use. This             Reading with the StAX is by XMLStreamReader .It is
allows the application to ignore the bits it doesn't care            the key interface in StAX. This interface represents a cursor
about, and just keep or use what is needed. SAX is often             that's moved across an XML document from beginning to
used in certain high-performance applications or areas               end. At any given time, this cursor points at one thing: a text
where the size of the XML might exceed the memory                    node, a start-tag, a comment, the beginning of the
available to the running program. In mainstream languages,           document, etc. The cursor always moves forward, never
event-based interfaces are usually implemented using                 backward and normally only moves one item at a time.
callback functions, a style familiar in graphical user                  There are a few ways to filter the event stream; of
interface (GUI) programming and the like. In object-                 course, you could use a stack of if-else statements instead of
oriented languages, callbacks are usually registered methods         the switch, but almost all StAX programs will feature an




                                                                8                             http://sites.google.com/site/ijcsis/
                                                                                              ISSN 1947-5500
                                                           (IJCSIS) International Journal of Computer Science and Information Security,
                                                                                                               Vol. 9, No. 5, May 2011
event loop something like this one. This is probably my
only major criticism of StAX. Integer type codes and big
switch statements are relics of procedural thinking. Object
oriented programs should be based around classes,
inheritance hierarchies, and polymorphism instead.
    StAX is a fast, potentially extremely fast, straight-
forward, memory-thrifty way to loading data from an XML
document the structure of which is well known in advance.
State management is much simpler in StAX than in SAX, so
if you find that the SAX logic is just getting way too
complex to follow or debug, then StAX is well worth                                    FIG.1. PARSING OF XML DOCUMENT
exploring. A few features such as validation, schema                     Like DOM, SAX parsers control the complete parsing
support, and entity resolution are either not available or are        process. By default, a SAX parser starts parsing at the
not functional in the current reference implementation, but           beginning of a document and continues until the end. Client
these should soon be available in independent                         event handlers are informed through callbacks about the
implementations [6]. StAX will be a very useful addition to           events during this parsing process. To avoid unnecessary
any Java developer's XML toolkit.                                     overhead during document screening, such an event handler
                    III.COMPARISION                                   may want to stop the parsing process once it has gathered
                                                                      the required information. A common technique for
    Java API for XML Processing (JAXP) provided two                   achieving this in SAX is throwing an exception. This will
methods for processing XML -- the Document Object                     cause SAX to stop the parsing process.
Model (DOM) method, which uses a standard object model
to represent XML documents, and the Simple API for XML
(SAX) method, which uses application-supplied event
handlers to process XML. Processing several XML
documents simultaneously can be a significant challenge.
SAX parsers, for example, deliver the parsing events
through callbacks to the client application. Because the
SAX parser controls this process, the client application does
not really have a chance to synchronize the different input                    FIG.2. C ONVERT THE XML INTO JAVA OBJECT MODEL
sources. Therefore, programmers usually resort to the DOM
parser when it comes to multi-document processing.                        The information gathered by the event handler must be
However, the penalty here is excessive resource usage; the            encoded in an error message that's wrapped in an exception
node trees of all input documents must completely reside in           object and posted to the parser's client. A special error
memory. In each step of the parsing Java object model is to           handler in the client receives this exception and must parse
be performed (Fig.1).                                                 the parser's error message to retrieve the required
                                                                      information. This may be a solution to the screening
    The screening or classification of XML documents is a             problem, but it's a complicated one. SAX parsers, for
common problem, especially in XML middleware. Routing                 example, deliver the parsing events through callbacks to the
XML documents to specific processors may require analysis             client application. Because the SAX parser controls this
of both the document type and the document content. The               process, the client application does not really have a chance
problem here is obtaining the required information from the           to synchronize the different input sources. Therefore,
document with the least possible overhead. Traditional                programmers usually resort to the DOM parser when it
parsers such as DOM or SAX are not well suited to this                comes to multi-document processing. However, the penalty
task. In the Fig.2 the XML document is converting to the              here is excessive resource usage; the node trees of all input
Java Object model.                                                    documents must completely reside in memory.
    DOM, for example, parses the whole document and                       StAX does not suffer from above drawbacks. As its
constructs a complete document tree in memory before it               name indicates, it is targeted at streaming applications such
returns control to the client. Even DOM parsers that employ           as the merging of two documents. The following example
deferred node expansion, and thus are able to parse a                 shows how this is done. Assume that you want to merge two
document partially, have high resource demands because                documents containing lists of products.
the document tree must be at least partially constructed in
memory. This is simply not acceptable for screening                       Streaming API for XML (StAX) completely changes
purposes.                                                             this. Unlike the Simple API for XML (SAX), StAX offers
                                                                      an API for writing XML documents. To be precise, it offers
                                                                      two      APIs:     a    low-level,  cursor-based      API
                                                                      (XMLStreamWriter), and a higher-level, event-based API
                                                                      (XMLEventWriter). While the cursor-based API is best
                                                                      used in data binding scenarios (for example, creating a
                                                                      document from application data), the event-based API is




                                                                 9                             http://sites.google.com/site/ijcsis/
                                                                                               ISSN 1947-5500
                                                                (IJCSIS) International Journal of Computer Science and Information Security,
                                                                                                                    Vol. 9, No. 5, May 2011
typically used in pipelining scenarios where a new                                       Entire document is not
                                                                                                                           No     built-in   document
document is constructed from the data of input documents.                                                                   navigation support
                                                                                          loaded into memory,
The cursor-based API offers a variety of specific methods                                                                  No random access to XML
                                                                                          resulting in low memory
                                                                                                                            Document
for creating the various elements of the XML information                         SAX      consumption
                                                                                                                           No support for modifying
set, such as elements, attributes, processing instructions,                              Allows registration of
                                                                                                                            XML in place.
data type declarations, and character content. These                                      multiple          content
                                                                                                                           No support for namespace
                                                                                          Handlers.
methods take care of many formatting issues. For example,                                                                   scoping.
the method writeCharacters() automatically escapes                                       Contains two parsing
characters like the less than sign (<), the greater than sign                             models, for ease of              No       built-in  document
(>), and the ampersand (&). And the method                                                performance.                      navigation support
                                                                                         Application         controls     No random access to XML
writeEndDocument() automatically closes all open                                 StAX     parsing, easily supporting        document
structures. So it does not matter if the last call to                                     multiple inputs                  No support for modifying
writeEndElement() in the example is commented out or not.                                Powerful            filtering     XML in place
                                                                                          capabilities        provide      Still in an immature state
    StAX can even generate namespace prefixes for                                         efficient data retrieval
namespaces that have not been formally declared.
javax.xml.stream.isPrefixDefaulting has been set to true for                                    IV.RESULT
the output factory. If this property has been set to false, you
                                                                               Based on time taken to parsing of the xml content with
must explicitly declare each namespace prefix and each
                                                                             JDOM, SAX and StAX techniques get data.
namespace using the methods setPrefix() and
writeNamespace(). Among the DOM and SAX widely used                          TABLE II      TIME TAKEN QUADC ORE PROCESSOR TO PARSE AN XML
methods, StAX provides the parsing efficiency and making
developer comfort. As StAX name indicates, it is targeted at                                             Time taken (nanoseconds)
streaming applications such as the merging of two
documents and exchange information between cooperating                       Nodes          JDOM                     SAX                  StAX
entities.                                                                    1          0.0543514280          0.0302972850          0.0229867110
    StAX allows an application to process multiple XML
                                                                             2          0.0551824870          0.0305735140          0.0230995120
sources simultaneously. For example: when one document
includes or imports another document, the application can                    3          0.0552194060          0.0308396360          0.0231593400
process the imported document while processing the
original document. This use case is common when the                          4          0.0552609610          0.0310450710          0.0232124300
application is reading documents such as XML Schemas or                      5          0.0552998820          0.0312222530          0.0232675710
WSDL documents [4]. StAX has two basic functions: To
allow users to read and write XML as efficiently as possible                 6          0.0553378660          0.0314174210          0.0233201160
and be easy to use (cursorAPI), and be easy to extend and
allow for easy pipelining.                                                   7          0.0553779660          0.0315977420          0.0233766030

    This approach of XML processing gives more control to                    8          0.0554156950          0.0317844120          0.0234354000
the client application than to the parser, enabling faster and
                                                                             9          0.0554545450          0.0319676010          0.0234957610
memory-efficient processing. This is becoming a standard
across different domains of XML processing. For example,                     10         0.0554942100          0.0321462610          0.0235535530
Apache Axis2, one of the prominent SOAP processing
engines, improved its performance four times, on average,                    11         0.0555336980          0.0323332980          0.0236119220
over its predecessor by using a StAX-based XML                               12         0.0555771380          0.0325268310          0.0236688970
processing model called Axiom. Axiom is more memory-
efficient and preferment than the existing object models                     13         0.0556225780          0.0327048640          0.0237263470
available today due to the usage of StAX as its XML                          14         0.0556670760          0.0328829090          0.0237855310
parsing technology.
                                                                             15         0.0557098490          0.0330663200          0.0238462250
       TABLE I       COMPARING THE JDOM, SAX, STAX
                                                                             16         0.0557561020          0.0332445070          0.0239056370
  Parser
                  Advantages                  Disadvantages
   APIs                                                                      17         0.0557997820          0.0334221430          0.0239639500
                                        XML document must be
            Rich set of APIs            parsed at one time                  18         0.0558468040          0.0336052810          0.0240300790
            Easy navigation            Expensive to load entire
                                                                             19         0.0558944750          0.0337868240          0.0240976250
 DOM        Entire tree loaded into     tree into memory
             memory, random access      Generic DOM node not                20         0.0559429890          0.0339688360          0.0241573290
             to XML document             ideal     for    object-type
                                         binding                             21         0.0559919680          0.0341568860          0.0242198540




                                                                        10                             http://sites.google.com/site/ijcsis/
                                                                                                       ISSN 1947-5500
                                                                                                                    (IJCSIS) International Journal of Computer Science and Information Security,
                                                                                                                                                                        Vol. 9, No. 5, May 2011
                                                                     Quad Core Execution (Parsing)                                                                                                           Pentium D Execution(parsing)


                                                                                                                                                            0.7000000000
                          0.0600000000
                                                                                                                                                            0.6000000000
                          0.0500000000
 T im e T a k e n ( N a n o S e c o n d s )




                                                                                                                                 T im e t a k e n ( n a n o s e c o n d )
                                                                                                                                                            0.5000000000
                          0.0400000000
                                                                                                                JDOM                                        0.4000000000                                                                                    JDOM
                          0.0300000000                                                                          SAX                                                                                                                                         SAX
                                                                                                                                                            0.3000000000                                                                                    Stax
                                                                                                                Stax
                          0.0200000000
                                                                                                                                                            0.2000000000

                          0.0100000000                                                                                                                      0.1000000000

                          0.0000000000                                                                                                                      0.0000000000
                                                     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21                                                                       0   1   2   3 4   5   6    7 8     9 10 11 12 13 14 15 16 17 18 19 20 21
                                                                                    Nodes                                                                                                                                Nodes



                                              FIG.3. T IME TAKEN BY Q UADCORE PROCESSOR TO PARSE AN XML                                                                     FIG.4. T IME TAKEN BY PENTIUM D PROCESSOR TO PARSE AN XML

TABLE II                                                 TIME TAKEN PENTIUM D PROCESSOR TO PARSE AN XML                           From the above graph in Fig 3 and Fig 4, StAX takes
                                                                                                                               minimum time than other parsers JDOM and SAX.
                                                                      Time taken (nanoseconds)
                                                                                                                                                  V.CONCLUSIONS
Nodes                                                     JDOM                          SAX             StAX
                                                                                                                                   Java API for XML Processing (JAXP) which processing
1                                                     0.5790705250             0.1829763280          0.0863534340              XML documents by using, the Document Object Model
                                                                                                                               (DOM) method, the Simple API for XML (SAX) method,
2                                                     0.6085354430             0.1833428550          0.0865333450              and Streaming API for XML (StAX) method are used
3                                                     0.6086161790             0.1836504360          0.0866400620
                                                                                                                               commonly. As StAX name indicates, it is targeted at
                                                                                                                               streaming applications such as the merging of two
4                                                     0.6086890940             0.1839482390          0.0867403540              documents and exchange information between cooperating
                                                                                                                               entities. StAX allows an application to process multiple
5                                                     0.6087569790             0.1842457630          0.0868412050              XML sources simultaneously. Among the DOM and SAX
6                                                     0.6088259820             0.1859532420          0.0869440110
                                                                                                                               widely used methods, StAX provides the parsing efficiency
                                                                                                                               and making developer comfort.
7                                                     0.6088958240             0.1862731160          0.0870443030
                                                                                                                                                                                                           REFERENCES
8                                                     0.6089712520             0.1865784620          0.0871476690              [1]                                            Rami Alnaqeib, Fahad H.Alshammari ,Zaidan.M.A, Zaidan.A.A.,
                                                                                                                                                                              Zaidan.B.B., Zubaidah M.Hazza (2010) “An Overview: Extensible
9                                                     0.6090441670             0.1868706780          0.0872543860
                                                                                                                                                                              Markup Language Technology”, in Journal of computing, Volume
10                                                    0.6091218300             0.1871617760          0.0873608240                                                             2, Issue 6, June 2010.
                                                                                                                               [2]                                            Nayak, Richi and Witt, Rebecca and Tonev, Anton (2002) “Data
11                                                    0.6092008900             0.1874640490          0.0875563800                                                             mining and XML documents”, In Proceedings International
                                                                                                                                                                              Conference on Internet Computing, IC'2002 3, pages pp. 660-666.
12                                                    0.6092768780             0.1877724680          0.0876628180              [3]                                            Guy Lapalme (2010) “Exploring and Extracting Nodes from Large
                                                                                                                                                                              XML Files” available at http://www.iro.umontreal.ca/~lapalme/
13                                                    0.6093567760             0.1880747410          0.0877661830                                                             ExamineXML.
                                                                                                                               [4]                                            Wei Zhang and Robert A. van Engelen (2009) “An Adaptive XML
14                                                    0.6094341600             0.1883831600          0.0878751350                                                             Parser for Developing High-Performance Web Services”, in
                                                                                                                                                                              proceedings of the International Symposium on Web Services
15                                                    0.6095171320             0.1886907410          0.0879947040                                                             (ISWS).
                                                                                                                               [5]                                            Antoniu Nicula, Doina Zmaranda and Codruţa Vancea (2010)
16                                                    0.6095973100             0.1891279480          0.0881047730                                                             “Issues       on       efficiency   of       XML         parsers”,
                                                                                                                                                                              http://www.rpbourret.com/xml/XMLData Binding.
17                                                    0.6096822370             0.1894360870          0.0882223860              [6]                                            Morris Matsa, Eric Perkins, Abraham Heifets, Margaret Gaitatzes
                                                                                                                                                                              Kostoulas, Daniel Silva, Noah Mendelsohn, Michelle Leger (2007)
18                                                    0.6097646490             0.1897319350          0.0883324560
                                                                                                                                                                              “A High Performance Interpretive Approach to Schema Directed
19                                                    0.6098479000             0.1900311350          0.0884402910                                                             Parsing“, in International World Wide Web Conference (IW3C2)
                                                                                                                                                                              paper.
20                                                    0.6099308710             0.1903364810          0.0885922660              [7]                                            Toshiro Takase, Hisashi Miyashita, and Toyotaro Suzumura,
                                                                                                                                                                              Michiaki Tatsubori, (2005) “An Adaptive, Fast, and Safe XML
21                                                    0.6100155190             0.1922856120          0.0887062470                                                             Parser Based on Byte Sequences Memorization” in International
                                                                                                                                                                              World Wide Web Conference (IW3C2) may 2005.




                                                                                                                         11                                                                                http://sites.google.com/site/ijcsis/
                                                                                                                                                                                                           ISSN 1947-5500
                                                                  (IJCSIS) International Journal of Computer Science and Information Security,
                                                                                                                      Vol. 9, No. 5, May 2011

                           AUTHOR PROFILE
1.   Mr.P.Krishna Sankar, M.E., Working as
     Assistant Professor, Dr. Mahalingam College of
     Technolgy, Pollachi, Coimbatore(Dt), Tamilnadu
     (State), India. Earlier, worked in IBM – India
     Software Lab, Bangalore as Software Engineer
     for a year. Completed Master of Engineering in
     Computer Science and Engineering in PSG
     College of Technology, Coimbatore (Dt),
     Tamilnadu (State), India and Bachelor of Engineering in Computer
     Science and Engineering in K.S.Rangasamy College of Technology,
     Tiruchengode, Namakkal (Dt), Tamilnadu (State), India. Have
     published 3 National Conference papers and performed 8 Technical
     Paper Presentations.
2.   Ms.N.P.Shangaranarayanee,      Student    pursuing
     Bachelor of Engineering in Computer Science and
     Engineering in Angel College of Engineering and
     Technology, Tirupur (Dt), Tamilnadu (State), India.
     Have published 1 National Conference paper and
     performed 4 Technical Paper Presentations.




                                                                        12                            http://sites.google.com/site/ijcsis/
                                                                                                      ISSN 1947-5500

				
DOCUMENT INFO
Shared By:
Tags: StAX
Stats:
views:156
posted:6/5/2011
language:English
pages:6