Knowledge Management Using XML and Blogs
An Alternative Approach to Multimedia Tagging
Justin Bolebruch
bolebruc@bc.edu
CS 335 Multimedia Systems
Professor Hao Jiang
Abstract
Typical knowledge management
applications require that users go through a process of tagging that associates
their document or information with a single, centrally designed and maintained
metadata set. Through the use of blogs
and XML, we can aim to improve this process.
Blogs are ideally suited for representing knowledge because they mirror
the ways that employees actual gather information on a daily basis. XML is a good solution because it allows data
to easily be stored, shared, and retrieved.
My project involves the implementation of four XML schemas to define
specific organizational data types, as well as four Java classes and
corresponding interfaces that serve as an XML Messenger, or “translator,”
between Blogs and XML documents. Overall
this project aims to provide an efficient way to extract data from blogs and
subsequently store it in XML documents based on defined schemas.
Introduction and Overview
Knowledge Management
Knowledge management is defined as the range of
practices to identify, create, represent, and distribute knowledge. Typical knowledge management applications
require that users go through a process of tagging that associates their
document or information with a single, centrally designed and maintained
metadata set. However, these
applications have faced numerous problems.
Principally, the technical design of knowledge management systems
differs from the actual process of knowledge creation by employees. For example, most information is stored in a
central database or data warehouse, yet most employees seek information through
interpersonal contacts with their coworkers.
Therefore, this project aims to explore a possible technical solution to
the problem of knowledge management.
Blogs[1]
Blogs represent a possible alternative technical
solution to current knowledge management systems. Blogs are much more adapted to the transitory
nature of the information that employees might gather on a daily basis and want
to share. In fact, a blog is a
successful electronic representation of the way that an individual employee:
·
Gathers knowledge
(incrementally, through time)
·
Shapes it and
refines it with the input of others through relationships and communication
(some of which is public and as derived from the work of others, some in direct
reaction), and
·
Presents
themselves and their identity to their coworkers and the organization.
XML
XML also presents a way to structure and store data in
a way that fits with current working practices.
Also, XML is very easy to read and understand for both humans and
computers. So what is XML?
·
XML is a markup
language for documents containing structured information
·
The primary
purpose of XML is to facilitate the sharing of structured data
·
XML provides a
way to define tags and the structural relationships between them
·
XML is designed
to describe data and focus on what data is
Method
Project Scope
The
implementation of my project involved two parts. The first was the creation of four XML
schemas to define data types. These four
schemas were “employee,” “blog,” “project,” and “keyword.” These four schemas were used in an attempt to
represent the information that is loosely stored in blog formats. The schemas also cross-reference each other,
so for example, an “employee” can appear as contributing to a “blog.” The goal for the XML schemas was to make it
easier to share, store, and use data in a way that was most useful and relevant
in a work environment.
XML schemas are used to describe the structure of an XML
document. They are used to define
elements that can appear in a document.
XML schemas also make it easier to describe allowable content, validate
the correctness of data, and work with data from a database. (XML schema files are indicated with a “.xsd”
ending.)
The four XML schemas are defined as such:
employee.xsd
•
Name
–
First
–
Last
•
Position
–
Position Title
–
Department
•
Blog Activity
List
–
Blog 1
(references blog.xsd)
–
Blog 2
•
Collaborators
–
Employee 1
–
Employee 2
blog.xsd
•
Posting
Statistics
–
Number of posts
–
Number of
different collaborators
–
Employees with
more than one post
–
Average number of
comments per post
•
Contributor List
–
Employee 1
(references employee.xsd)
–
Employee 2
•
Level of Posting
Activity
–
Age of the blog
–
Time since last
post
project.xsd
•
Blog List
–
Blog 1
(references blog.xsd)
–
Blog 2
•
Number of Blogs
in the Project
keyword.xsd
•
Associated
Employees
–
Employee 1
(references employee.xsd)
•
Associated Blogs
–
Blog 1
(references blog.xsd)
•
Associated
Projects
–
Project 1
(references project.xsd)
XML Messenger
The second part of my project consisted of an XML Messenger
API that would serve as a “translator” between information from a blog and an
XML document. The XML Messenger consists
of four Java classes and associated interfaces.
These classes are based on the XML schemas for employee, blog, project,
and keyword. The Messenger API allows
for data be added and stored, and then written to properly formed XML
files. The XML Messenger functions
solely as the intermediary translator between blogs and XML documents. For example, it does not search the blogs for
information; instead, when changes are made to the blog, the information is
stored and translated by the Messenger.
An XML document is then formatted, but not stored. The actual process of storing the documents
in a database is up to the developers.
This allows for the XML Messenger
to be very open to developer needs. It
can be used in a variety of ways, and does not provide much computational
complexity. The developer is thus free
to develop the blog and the database separately, but can use the XML Messenger
to easily format XML documents based on the schemas and the information in the
blogs.
Here is an example of how the
system could function:
Here, we see how the XML
Messenger functions as the single translation point between multiple blogs,
multiple XML documents, and multiple users.
This illustrates the basic
concept for the XML Messenger. With
blogs, we can represent knowledge very well, but information is not centrally
organized and not easily accessible.
While each individual blog is very valuable, multiple blogs, users, and
projects creates a situation where we have no concise or structured view of the
data.
The XML Messenger takes
information from a blog and formats XML documents based on the defined XML
schemas. It converts the blog information
into XML syntax, thus automating the process of formatting. This can thus be done for a large number of
blogs.
With the formatted XML
documents, we now have a much more structured view of the information. These documents can now be centrally stored,
shared, and retrieved by users.
The XML Messenger has taken
the information from blogs (unstructured) and created a much more concise view
that works well with existing databases.
Here is another example of
how the posting process might work, incorporating the XML Messenger API:
Results
Sample data for an employee
and blog were implemented into the XML Messenger. These are examples of the XML files that
would result from the Messenger:
Code Samples:
Java Classes:
Java Interfaces:
XML Messenger Test Class: