<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Interview: David Wilson, Bibliograhic Project</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body><h2>Interview: David Wilson, Bibliographic Project</h2>
<p>2003-10-13</p>
<p><a href="../lspintro.html">-Louis Suarez-Potts</a></p>

<p class="Header">David N. Wilson: Bibliographic Project (Incubator) Lead</p>
<p>For several months now David Wilson has been the lead of the <a href="http://bibliographic.openoffice.org/">Bibliographic Project</a>, which he founded.  Located in the <a href="http://incubator.openoffice.org/">Incubator Category</a>, Bibliographic aims, as its mission statement explains, "to provide an easy to use but comprehensive bibliographic function within OpenOffice.org. The planned bibliographic function will utilise the latest open standards and will make the fullest use of emerging XML technology."  It is in many ways a classic Incubator Project, creating a tool that extends OpenOffice.org.  If you are interested in participating in the project and helping out, please join it and subscribe to the relevant <a href="http://bibliographic.openoffice.org/servlets/ProjectMailingListList">mailing lists</a>.  </p>

<p>The following interview was conducted via email Friday 2003-10-10 and lightly edited.</p>
<hr>

<p>
<i>Tell us something about yourself, how you got interested in OpenOffice.org and
in creating the Bibliographic Project.</i>
</p>

<p>
My early education was in the Arts and I studied Politics and Sociology, but moved on to Information Technology to get employment. I worked for 20 years in a large corporation in many areas of IT.  I have done some application and database design, but very little programming, as I am a very slow and bad programmer. 
</p>

<p>
When you reach the point when the <a href="http://www.unitedmedia.com/comics/dilbert/">Dilbert cartoons</a> seem exactly to capture your daily experience in corporate life, it is time to move. So I left the Corporation and went back to University to study history. I am currently doing a MA thesis on the early Irish sagas.
</p>

<p>
My involvement with open-source software started about the time I began my history assignments. Having software X trash my essays got too much and I moved to Linux (no files lost since) and StarOffice - OpenOffice.org. I quickly found that OpenOffice.org did not support the citation method that my history department demanded - Chicago Style footnote citations. Having thought about what was required to fix these deficiencies I sent in a large number of enhancement requests to cover the limitations I found. The response to this barrage of suggestions was that I was invited to set up an Incubator project to develop the enhancement suggestion into a comprehensive redesign proposal. I accepted and the project group is in the process of planning the redesign.
</p>

<p><i>What is the purpose of the Bibliographic Project?  What do you hope to accomplish?  Who would benefit from this project?</i>
</p>

<p>
The purpose of the project is to enable OpenOffice.org users to manage bibliographic information, such as quotations, references, source details of pictures and charts, etc. The Bibliographic facility should then allow the user to select an appropriate standard for the presentation of that data for the initial citation and for the bibliographic tables. Effective bibliographic support is critical for academic and technical workers and OpenOffice.org will not achieve widespread acceptance in these areas until we improve it.
</p>

<p>
There are many bibliographic standards. It is a tedious, difficult and error-prone to manually write all the citations and bibliographic tables in a large document. And when someone is submitting a MA or PhD thesis, or a journal article, they do not want to see it come back with red marks from examiners or editors. The bibliographic presentation process can be fully automated, and that is what we hope to accomplish. 
</p>

<p>
Currently people who want to use the type of facilities I have described, need to purchase commercial products ¯ add-on software such as <a href="http://www.endnote.com/">Endnote</a>, <a href="http://www.refman.com/">Reference Manager</a>, <a href="http://www.biblioscape.com/">Biblioscape</a> ¯ or an Academic word processor such as <a href="http://www.notabene.com/">Nota Bene</a>. (Nota Bene has many of the features I would like to see in OpenOffice.org.) The few open-source applications (e.g., <a href="http://www.santafe.edu/~dirk/sixpack/">Sixpack</a>, <a href="http://www.jurawiki.de/pybliographic">Pybliographic</a>, etc.) are much more limited than the commercial products. Many of the people who would benefit most from bibliographic management software are students, who often cannot easily afford commercial software. I am also inspired by the thought of providing such useful software for free to other people who could never afford to buy the commercial software.
</p>

<p>
Another group that would benefit from this project are University staff and workers in scientific and technical areas, many of whom work in open-source software environments.
</p>

<p><i>How are you going about doing what you are doing?  What is the collaborative environment like? Where are there problems, successes?</i>
</p>

<p>
I started the project by canvassing my ideas on the <a href="//servlets/SummarizeList?listName=users&amp;JServSessionIdservlets=fnlqp4mz53">users@openoffice.apache.org</a>. I received quite strong support from people around the world. So I set up the Bibliographic Incubator project web pages to present my ideas and to map a development path. The <a href="http://www.collab.net/">CollabNet</a> website structure has made it simple to set up and manage the project web pages and discussion lists.
</p>

<p>
The project now has 30 registered observer participants, and we have had good discussions about the project. The project members are, not surprisingly, mostly university students and academics and scientific workers. Given the membership, the skill set of the project is largely user-requirements orientated, however, we have a some members, such Bruce D'Arcus, who are active in bibliographic standards development and promotion. We also have people associated with the project who are expert in XML representation of bibliographic data, and some who are involved in the related open-source projects, <a href="http://refdb.sourceforge.net/">Refdb</a> and Pybliographic.
</p>

<p>
Milestones so far: Kirk Job-Sluder has conducted, and reported the findings of a Bibliographic User requirements Study with some interesting conclusions for the project. Manish Agrawal has put in lot of work into producing the Bibliographic User Requirements and Functional Specifications documents. (see the project web pages <a href="http://bibliographic.openoffice.org/">http://bibliographic.openoffice.org/</a> for details).
</p>
  
<p>
We have two streams of activity, short term projects to get some small bits of development work done quickly for urgently needed functions like bibliographic database import/export filters. A couple of volunteers are currently finding their way about OpenOffice.org internals in order to start on a couple of these projects.
</p>

<p>
The second stream is the total redesign and development of the bibliographic facilities. For this, we need to ensure that the User Requirements and Functional Specifications are complete, and to find people able to start the technical design. The design and development of the Bibliographic facilities is an exciting project which will include
</p>

<ul>
	<li>greatly improved Graphic User Interface for adding, editing and searching bibliographic records. </li>
	<li>An enhanced bibliographic database, based upon the emerging industry standard - MODS </li>
	<li>Bibliographic citation and table generation via XSLT style sheets. </li>
	<li>Support for all the common styles and conventions for citations and bibliographic tables. </li>
	<li>The ability to change a document from one style to another with minimal or no further editing. </li>
	<li>Import and export filters for the common formats for bibliographic data.</li>
	<li>The ability to tag text and other document objects (quotations, tables, charts etc.) with their source metadata. </li>
	<li>The ability to connect to, and to exchange data with, other bibliographic databases. </li>
	<li>The ability to query internet reference sources (e.g. reference databases and library catalogs) </li>
</ul>
 
<p>The project's major problem it that we have neither yet developed the skills internally nor attracted skilled application designers and developers to the project. I am sure we will be able to progress into application design with our current skills we have but it will be difficult to go much further than that without extra development skills. 

That said, one of the problems in attracting developers has been the difficultly faced by people in getting an understanding of the complex OpenOffice.org development environment. However, the new OpenOffice.org developers' pages at <a href="http://bibliographic.openoffice.org/developer.html">http://bibliographic.openoffice.org/developer.html</a> are a big advance and I think they will greatly assist people who want to get started.  </p>


<p>
<i>Where do you see the project going? And, how can people help?</i>
</p>

<p>
We hope to have built some bibliographic database import and export filters within a few months. The redevelopment of the Bibliographic facilities is dependent upon the tag-handling module plug-in framework that will come with OpenOffice.org version 2 (due mid- to late-2004). This gives us some time to develop our design and sets a time frame for us to work in.
</p>

<p>
We have a project team of skilled and knowledgeable people who understand the bibliographic requirements, and have assisted in developing the concepts needed for the application redesign. But we still need people with direct application development skills to assist us.
</p>

<p>
But other skills are also needed, such as documentation skills - people have requested simple bibliographic 'How To' information, 'Tips and Hints' etc. Even with the current limited facilities bibliographic style templates could be produced. Also people to offer encouragement and advice.</p>
</body>
</html>
 
