<html><head>
	<title>Abstracts of Conference Papers - Friday</title>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<link rel="stylesheet" href="conference.css" media="screen" type="text/css" />
	<!-- >
	$Id: fri_dev.html,v 1.12 2004/08/27 16:47:12 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_red.gif" width="52" height="17" alt="image" /></td>
    		<td><h2>Abstracts of Conference Papers - Friday</h2></td></tr>
	</table></td></tr>

<!--
	<tr>
		<td>
			<table width="100%" id="D7" name="D7" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="dev">
						<strong><a name="D7"></a>OpenOffice.org / StarOffice Roadmap</strong>
					</td>
				</tr>
				<tr>
					<td>Michael Bemmer, Dieter Loeschky <em>Sun Microsystems, Inc.</em></td>
				</tr>
				<tr>
					<td><p></p>
					</td>
				</tr>
				<tr>
					<td id="D7b"><em></em>
					</td>
				</tr>
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
-->
			<table width="100%" id="D8" name="D8" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="dev"><strong><a name="D8"></a>The OpenOffice.org Roadmap: Thoughts on "Release Early and Often" vs. "It's Done When It's Done"</strong>
					</td>
				</tr>
				<tr>
					<td>Matthias Huetsch <em>StarOffice Architect, Sun Microsystems, Inc.</em></td>
				</tr>
				<tr>
					<td><p>This session intends to start a (high-level) discussion on the roadmap for future OOo releases.</p>
						<p>To that end, we start with a short history of OOo from it's beginnings in Oct 2000 to
						the OOo 2.0 release, currently planned for Spring 2005, and observe a release cycle of
						approximately 18 months.</p>
						<p>Though this release cycle diverts from the classical open source "Release Early and Often"
						principle, we still see overlapping development and release cycles, and "continuous" feature
						increments.</p>
						<p>Based on a development model of "Child Workspaces" and "Master Workspaces", we currently
						deliver quarterly (bug fix) Updates of "Current Release" (1.1.x) and bi-weekly (feature)
						Milestones of "Next Release" (2.0).</p>
						<p>As this development model could also support shorter (feature) release cycles, provided
						obvious challenges (planning and organizing the many workspaces) can be addressed, we already
						seem to have an answer to the question of "How could we (technically) release early and often?".</p>
						<p>But, apparent limitations of short release cycles (user expectations on minimum feature
						increments, the "it's done when it's done" principle), lead to the more fundamental question
						of "How can we best account for the needs of all stakeholders in OOo?".</p>
					</td>
				</tr>
				<!-- tr>
					<td id="D8b"><p><em>Biography:</em></p>
					</td>
				</tr -->
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
			<table id="C12" name="C12" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="dev">
						<strong>Simplifying the User Interface Layout Process</strong>
					</td>
				</tr>

				<tr>
					<td>Dan Williams
					<em>Desktop Software Engineer, Red Hat, Inc.</em></td>
				</tr>

				<tr>
					<td><p>The time has come to adopt a new method of designing and displaying the OpenOffice.org
					user interface. Imagine using tools like Qt Designer or Glade and never touching a .src file again.
					The current text-file based process is quite cumbersome, inelegant, confusing, and not conducive
					to internationalization efforts either. </p>

					<p>To attract new developers and make current developer's jobs easier, OpenOffice.org should
					gradually transition to graphical user-interface layout tools, and a layout-based window/widget
					display system. While this might sound boring, these changes have the potential to make
					OpenOffice.org much more exciting for developers and lower the bar for newcomers. The paper
					will touch on the current resource-based system, the reasons for proposing a new UI layout system,
					and possible implementation strategies. Part of the session should be reserved for discussions
					of a more technical nature.</p>
					</td>
				</tr>

				<tr>
					<td><em>Biography: Dan has been involved with OpenOffice.org development since 2001,
					beginning with the Mac OS X port and helping it limp and crawl through several releases.
					He now works for the Red Hat, Inc., Desktop Team primarily on OpenOffice.org, continuing
					with the Mac OS X port as well. Areas of interest include low-level graphics, OOo user
					interface/toolkit, porting, and generally making life better for OOo users even though they
					might not know it. Other interests include archeology and Eastern European history. </em>
					</td>
				</tr>
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>

			<table width="100%" id="D9" name="D9" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="dev"><strong><a name="D9"></a>Native Installer for OpenOffice.org 2.0</strong>
					</td>
				</tr>
				<tr>
					<td>Ingo Schmidt <em>Software Engineer, Sun Microsystems, Inc.</em></td>
				</tr>
				<tr>
					<td><p>In OpenOffice.org 2.0 the old installation method used in OpenOffice.org 1.x versions is
					no longer supported. Instead the operating system specific native installers will be used for
					installation. This allows a more operating system conforming installation process and a better
					product integration into the specific operating system.</p>
						<p>This session will give an overview about the new packaging process for OpenOffice.org 2.0.
						It contains the platform independent installationset description language, the setup script
						that contains a platform specific product description and the new tooling that creates the
						native installation sets based on the information in the setup scripts. The new process also
						includes the free software ESP Package Manager (ESP = Easy Software Products) that supports the
						creation of many different native installers and uses its own platform independent
						installationset description format. The results of the complete new process are for example
						Windows Installer installation sets for the Windows platforms, Solaris packages for the Solaris
						platform or RPMs for Linux.</p>
						<p>This talk will also give an overlook about the current support of the different operating
						systems and the possibilities for operating systems that are not yet supported.</p>
					</td>
				</tr>
				<tr>
					<td id="D9b"><p><em>Biography: Ingo has been working on StarOffice at Star Division /
						Sun Microsystems for more than 6 years in program management and software development. Last
						year he started the process to introduce native installer as substitute for the old
						OpenOffice.org/StarOffice specific setup application.</em></p>
					</td>
				</tr>
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
			<table width="100%" id="D10" name="D10" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="dev">
						<font color="#FFFFFF"><strong><a name="D10"></a>Here Come UNO, All Shiny and New</strong></font>
					</td>
				</tr>
				<tr>
					<td>Stephan Bergmann <em>Sun Microsystems, Inc.</em></td>
				</tr>
				<tr>
					<td><p>The Universal Network Objects (UNO) technology - that underlies the OpenOffice.org programming
					interface - has recently been enhanced with a set of capital new features. The unifying theme
					of the various improvements is to increase the ease with which all kinds of developers can use
					UNO. This session demonstrates how the OpenOffice.org API and its accompanying Software
					Development Kit (SDK) can benefit from these features, both for developers that use the API
					and SDK to build their own solutions on top of OpenOffice.org, in whatever programming language,
					and for developers who extend the OpenOffice.org API itself.</p>
					</td>
				</tr>
				<tr>
					<td id="D10b"><p><em>Biography: Stephan works for Sun Microsystems for quite some time now, on various
					aspects of OpenOffice.org and StarOffice. His recent activities are directed at pushing the
					usability of UNO.</em></p>
					</td>
				</tr>
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
			<table width="100%" id="D11" name="D11" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="dev"><strong><a name="D11"></a>Learn from the South African 11 language localisation experience</strong>
					</td>
				</tr>
				<tr>
					<td>Dwayne Bailey Director <em>Translate.org.za</em></td>
				</tr>
				<tr>
					<td><p>The Translate.org.za project localises various pieces of Free Software into the 11
					official languages of South Africa.  The founder of the project will explore lessons learnt
					in terms of fund raising, creating a volunteer community, frustrations with tools and processes
					and raising market awareness.</p>
						<p>The talk will touch on why OpenOffice.org is currently the most important localisation
						target for Free Software by using and explaining Translate's software selection criteria.
						But will also talk about some of the frustrations found in the OpenOffice.org localisation method
						and systems and how these have been overcome or subverted.</p>
						<p>The talk will also cover the difficulties of manging multiple languages and multiple
						target projects and ideas on how to minimise these problems.  The talk will briefly look
						at the tools that the project has created to minimise the incompatibilities of various
						localisation projects and the tools used to provide simple QA of translations.</p>
					</td>
				</tr>
				<tr>
					<td id="G11b"><p><em>Biography: Dwayne Bailey is the founder of the Translate.org.za project
					an ambitious project that is translating Free Software into the 11 official languages of
					South Africa.  The Translate project falls under the Zuza Software Foundation whose mandate
					is the development of Free software for upliftment and empowerment. Dwayne is also a director
					of the Foundation.  He is now focusing efforts to increase the number of similar projects
					throughout Africa and other developing countries and sees the emerging role of Translate.org.za
					being that of skilling and equipping other translation teams.</em></p>
						<p><em>He has a keen interest in policy and the adoption of FOSS in education. Dwayne was
						one of the drafters of the initial South African Government Opensource advisory document
						that initiated much policy development on OSS in the South African government.</em></p>
					</td>
				</tr>
			</table>
  <p><a href="friday.html">Back to Friday</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>
      </td>
    </tr>
  </table>

  <hr />

