<html><head>
	<title>Abstracts for BOF Sessions - Thursday</title>

	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<link rel="stylesheet" href="conference.css" media="screen" type="text/css" />
	<!-- >
	$Id: thurs_bof.html,v 1.5 2004/09/08 15:12:16 st Exp $
	< -->
</head>

<table id="top" name="top" summary="" border="0" cellspacing="5" cellpadding="5">
	<tr><td><table width="100%" summary="" ><tr>
			<td><img src="../conference/group_blue.gif" width="52" height="17" alt="image" /></td>
    		<td><h2>Abstracts for BOF Sessions - Thursday</h2></td></tr>
	</table></td></tr>

	<tr>
		<td>
			<table id="B1" name="B1" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="general">
						<strong>Funding the OpenOffice.org Project</strong>
					</td>
				</tr>

				<tr>
					<td>Louis Su&aacute;rez-Potts <em>OpenOffice.org Community Manager</em></td>
				</tr>

				<tr>
					<td>OpenOffice.org receives nearly all its operating funds from Sun Microsystems.  It also
					accepts donations from outside sources.  We have struggled to define policies that allow
					us to accept funds without affecting the volunteer nature of the community.  But the funds
					we have so far received have been small.  This BOF would investigate the issues at stake in
					more aggressively seeking funds as well as discuss their distribution.</td>
				</tr>

<!--				<tr>
					<td><em>Biography: </em>
					</td>
				</tr>-->

			</table>

			<p><a href="thursday.html" title="Agenda for Thursday">Back</a></p>

			<table id="B2" name="B2" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="general">
						<strong>Defining and Extending OpenOffice.org (the product)</strong>
					</td>
				</tr>

				<tr>
					<td>Louis Su&aacute;rez-Potts <em>OpenOffice.org Community Manager</em></td>
				</tr>

				<tr>
					<td><p>How is OpenOffice.org the product defined?  What are the processes? And
					how are the various parts of the community involved? This paper addresses the mostly
					political (but also technical) problematic of defining the OpenOffice.org code (source and
					binaries).  The current structure, in which Sun proposes de facto definitions that the overall
					community then more or less silently endorses has allowed OpenOffice.org to maintain a
					coherent developmental trajectory and minimize fragmentation. However, in the last year,
					local community desires have begun to challenge the consensual system.</p>

					<p>This paper briefly will also propose a political (not technical) logic for extending
					OpenOffice.org functionality.</p>
					</td>
				</tr>

<!--				<tr>
					<td><em>Biography: </em>
					</td>
				</tr>-->

			</table>

      </td>
    </tr>
  </table>

<p><a href="thursday.html" title="Agenda for Thursday">Back</a></p>

<table summary="" border="0" cellspacing="5" cellpadding="5">
	<tr><td><table width="100%" summary="" ><tr>
			<td><img src="../conference/group_red.gif" width="52" height="17" alt="image" /></td>
    		<td><h2>Abstracts for BOF Sessions - Thursday</h2></td></tr>
	</table></td></tr>

	<tr>
		<td>
			<table id="B4" name="B4" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="dev">
						<strong>UNO Vision - UNO as the common Middleware for
						Open Source software</strong>
					</td>
				</tr>

				<tr>
					<td>J&uuml;rgen Schmidt, Kay Ramme <em></em></td>
				</tr>

				<tr>
					<td><p>This session explores the opportunities offered by having a separate Uno Runtime
					Environment (URE). A URE allows to program UNO components or applications independent
					of OpenOffice.org. A URE would be available as a separate installation unit (.rpm, .msi, ...)
					and would be installed into the operating system. Opportunities can be such things as having
					UNO as a common middleware, UNO providing an object request broker (ORB), interapplication
					component re-usage, high interoperability and more.</p>

					<p>Outline:</p>
					<UL>
						<LI>introduction
							<LI>overview of the URE
							<LI>opportunities of a common component model
							<LI>thoughts about having an UNO ORB
							<LI>discussion
						</UL>
					</td>
				</tr>

<!--				<tr>
					<td><em>Biography: </em>
					</td>
				</tr>-->

			</table>

			<p><a href="thursday.html" title="Agenda for Thursday">Back</a></p>

			<table id="B5" name="B5" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="dev">
						<strong>A Quality Official Localized Build</strong>
					</td>
				</tr>

				<tr>
					<td>Kazunari Hirano <em>Translator, TranSwift</em></td>
				</tr>

				<tr>
					<td>BOF style discussion on better build, bugfix and QA processes and better
					communication among developers, engineers and community members to create a Quality
					Official Localized Build and to allow the release engineering team to release it for each platform.
					Hope to make an agreement on the processes and the way of communication.
					</td>
				</tr>

				<tr>
					<td><p><em>Biography:</em></p>
					<UL>
						<LI><em>1984 Graduated, Vietnamese Department, Tokyo University of Foreign Studies</em>
						<LI><em>1984 Journalist at a news agent, Nihon Denpa News, Co., Ltd.</em>
						<LI><em>1989 Staff at ANC Tokyo Office.</em>
						<LI><em>1994 Investigation of ethnic groups in Vietnam and cultural exchange between
						Vietnam and Japan at MIRAI Co., Ltd.</em>
						<LI><em>1997 Technical Translator at Microsoft Chofu Technical Center.</em>
						<LI><em>2001 Freelance Translator and Interpreter.</em>
						<LI><em>2003 Staff at OpenOffice.org Japan Users Group</em>
					</UL>
					</td>
				</tr>
			</table>

			<p><a href="thursday.html" title="Agenda for Thursday">Back</a></p>


			<table id="B7" name="B7" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="dev">
						<strong>Translation Technology At Sun Microsystems, Inc.</strong>
					</td>
				</tr>

				<tr>
					<td>Tim Foster</td>
				</tr>

				<tr>
					<td><p>
This paper aims to show how Sun Microsystems, Inc., uses translation
technology for its translation activities on StarOffice and other
projects. This material was presented at the GUADEC conference this
year, but might also be of interest to the OpenOffice.org community.
</p>
<p>
Primarily, we will share our experiences of how the use of open
standards such as XML Localization Interchange File Format (XLIFF) and
Translation Memory eXchange format (TMX) and the use of tools to process
these formats can increase translator productivity and aid in the
sharing of translations across multiple projects.
</p>
<p>
We will demonstrate our translation editor which has been developed
in-house and has been in use for several months on real-world
translations. In keeping with our tradition of supporting open
standards, our editor can load and save XLIFF files and can export TMX
files for use with other translation tools. We have had extensive
feedback from professional translators who have been using the system in
production and we will explain some of the features that were added to
accommodate their needs.
</p>
<p>
Finally, we will present our vision of translation technology and the
advantages it can bring to increase translator productivity and
translation accuracy.
					</p>
					</td>
				</tr>

				<tr>
					<td><em>Biography:
					Tim has been working on localization and internationalization
					related activities at Sun for about 7 years and is currently
					working on tools to
					assist in the translation of software and documentation.
					</em>
					</td>
				</tr>

			</table>

			<p><a href="thursday.html" title="Agenda for Thursday">Back</a></p>

<!--
			<table id="B3" name="B3" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="dev">
						<strong>The OpenOffice.org Porting Project</strong>
					</td>
				</tr>

				<tr>
					<td>Kevin Hendricks, Martin Hollmichel <em></em></td>
				</tr>

				<tr>
					<td>An overview about the OpenOffice.org porting projects for various platforms will be given.
					The different hurdles when doing a port to a new platform like a 64bit operating system or small
					device platform will be given as examples.
					</td>
				</tr>

-->
<!--				<tr>
					<td><em>Biography: </em>
					</td>
				</tr>-->

			</table>
		</td>
	</tr>
</table>
  <hr />

  <p><a href="thursday.html">Back to Thursday</a><br />
   <a href="#top">Back to Top</a><br />
 <!--  <a href="agenda2.html">Back to Overview</a></p>-->

  <p>Please Note: Program content subject to change.</p>
