<html><head>
	<title>Abstracts of Conference Papers - 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_general.html,v 1.7 2004/08/24 08:21:53 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 of Conference Papers - Thursday</h2></td></tr>
	</table></td></tr>

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

				<tr>
					<td class="general">
						<strong><a name="G1" id="G1"></a>Evaluating and Supporting OpenOffice.org in the Public Administration:
						the COSPA project.</strong>
					</td>
				</tr>

				<tr>
					<td>Paolo Zuliani <em>Assistant Professor, Free University of Bolzano-Bozen, Italy</em></td>
				</tr>

				<tr>
					<td>Public Administrations spend every year a considerable amount of money for Commercial
					Off-The-Shelf software licenses. By using appropriate technologies, such expenses might be either
					dramatically reduced, or re-routed to further develop local business ecosystems. The COSPA project
					aims at introducing, analysing, and supporting the use of Open Data Standards and Open Source
					software for personal productivity and document management in the Public Administration. COSPA
					will perform pilot projects throughout many European Public Administrations for benchmarking and
					analysing costs and benefits of migrations to Open Source Software. In particular, the project focuses
					on OpenOffice.org as the main personal productivity suite. COSPA is funded with 2,6 million euro by
					the 6th Framework Programme of the European Union and runs from January 2004 to December 2005.
					</td>
				</tr>

				<tr>
					<td><em>Biography: After receiving a Laurea Degree in computer science in 1997 from Universit� degli
					Studi di Milano, Italy, Mr. Zuliani began graduate studies at Oxford University. He completed his work
					toward a Ph.D. degree as a member of the Programming Research Group in the Computing Laboratory
					under the supervision of Dr. Jeff Sanders. He is currently Assistant Professor in the Faculty of Computer
					Science at the Free University of Bolzano-Bozen, Italy.</em>
					</td>
				</tr>

			</table>

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

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

				<tr>
					<td class="general">
						<strong><a name="G2"></a>Where can I find new features in OpenOffice.org 2.0?</strong>
					</td>
				</tr>

				<tr>
					<td>Sophie Gautier and Elizabeth Matthis <em>Members of the OpenOffice.org Marketing Project</em></td>
				</tr>

				<tr>
					<td>We would like to present the Guide to New Features that we have compiled. It includes
					descriptions of the new features in OO.o 2.0 as well as where they can be accessed in the
					office suite. We'll show you what it looks like and where to find it if you want to have a closer
					look, translate it into your language, and/or use it to market OO.o.
					</td>
				</tr>

				<tr>
					<td><p><em>Biography: Sophie and Elizabeth have been members of the OO.o marketing project
					almost since day one. They are both enthusiastic community members who do what they can
					to get the word out about how good OpenOffice.org is. In addition to the general OO.o marketing
					mailing list, Sophie can be found on the French lists and Elizabeth can be found on the German lists.</em></p>

					<p><em>>Elizabeth is employed by Sun Microsystems on the StarOffice/OpenOffice.org User Experience team.
					Sophie is a volunteer, OpenOffice.org francophone project leader and marketing contact for West Africa.</em></p>
					</td>
				</tr>

			</table>

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

				<tr>
					<td class="general">
						<strong><a name="whatsnew"></a>What's New in OO.o 2.0 (Live Demo)</strong>
					</td>
				</tr>

				<tr>
					<td>Falko Tesch <em>Product Manager User Experience, Sun Microsystems</em></td>
				</tr>

				<tr>
					<td><p>A live demonstration of OpenOffice.org 2.0 EA showing and explaining the major new features,
					like new toolbars and menus, new database, XForms, new multi-pane view of Impress and AutoShape
					support, better system integration, scripting framework as well as MS Office filter updates.</p>

					<p>I will also give an in-depth look on the impact of these features in relation to MS Office and the office
					productivity suite market in general.</p>
					</td>
				</tr>

				<tr>
					<td><p><em>Biography: Being with Sun (resp. Star Division) for more than 7 years I worked in
					various fields with and for StarOffice/OpenOffice.org.</em></p>

					<p><em>Currently I'm working in Sun's User Experience Team for StarOffice/OpenOffice.org with main
					focus on internationalization and presentations.</em></p>
					</td>
				</tr>

			</table>

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

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

				<tr>
					<td class="general">
						<strong><a name="G3"></a>Document and Forms Management with OpenOffice.org</strong>
					</td>
				</tr>

				<tr>
					<td>Niels Mache <em>CEO, struktur AG</em></td>
				</tr>

				<tr>
					<td><p>OpenOffice.org is much more than yet another Office suite. On the desktop OpenOffice.org
					provides a whole set of office applications where on the server side, OpenOffice.org powerful
					document processing capability brings document control to business information throughout
					the document lifecycle. </p>

					<p>This session will provide live examples of how OpenOffice.org integrates with document and
					user management, helping to lower total cost of ownership. It will also explore why
					OpenOffice.org open standards protect the enterprise investment in IT infrastructure. </p>
					</td>
				</tr>

				<tr>
					<td><p><em>Biography: Niels Mache is the technical and product visionary of struktur AG.</em></p>

					<p><em>Niels Mache graduated with a Masters of Science in computer science and computational
					biology from the University of Stuttgart, Germany. Niels Mache is a true Open Source
					software pioneer. He published his first Open Source software in 1989.</em></p>

					<p><em>His entrepreneurial spirit led him to provide commercial Linux support and to co-found delix,
					a company providing Linux software and support. In 1999, delix' operations were acquired by
					Red Hat Inc., USA. Niels formerly served as director of development for Red Hat GmbH, leading
					the development of Red Hat Linux in Germany. Prior to his position at Red Hat, Niels Mache
					served as R&amp;D engineer at Sony Telecommunication Research and Development Europe.</em></p>
					</td>
				</tr>

			</table>

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

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

				<tr>
					<td class="general">
						<strong><a name="G4"></a>OpenOffice.org/StarOffice - Migration, a methodology in a
						professional environment</strong>
					</td>
				</tr>

				<tr>
					<td>Lothar K. Becker <em>Managing Director, .riess applications GmbH</em></td>
				</tr>

				<tr>
					<td><p>The spirit of Open Source together with the features of a high professional office
					software package has tremendously increased the interest in StarOffice or OpenOffice.org
					for a huge amount of companies all over the world. It provides a real chance for lower total
					cost of ownership for large scaled companies. On the other hand there are a lot of risks
					in the migration path, which should be covered by a clear and straight forward methodology.</p>

					<p>It starts in the decision process for the migration to StarOffice/OpenOffice.org itself, where tremendous
					faults could be made, and it does not end in the right user education after the launch of a new
					office package. </p>

					<p>This presentation offers a step by step approach, in which the whole process of a migration is
					covered. It is designed for large scaled companies with toolkits for automatic analysis and
					document conversion. Nevertheless it gives hints for non technical issues in the migration path
					as well as it outlines borders and show stopper. It is based on experiences in successful
					OpenOffice.org/StarOffice migration projects for professional companies of many branches.
					The practical experiences of .riess as Sun's first StarOffice Migration Partner in Germany
					offers precious guidance in your considerations in introducing StarOffice.</p>
					</td>
				</tr>

				<tr>
					<td><em>Biography: Lothar K. Becker is the Managing Director of .riess applications until first
					half of 2004. Before he reached .riess he was responsible for the competence center and sales
					and marketing department of a software and service company. After his degree in Computer Science
					he first focused his work in software consulting and project management for ten years. </em>
					</td>
				</tr>

			</table>

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

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

				<tr>
					<td class="general">
						<strong><a name="G5"></a>Integration of StarOffice / OpenOffice.org with Tamino</strong>
					</td>
				</tr>

				<tr>
					<td>Robert Diawara <em>Sales Consultant, Software AG</em></td>
				</tr>

				<tr>
					<td>Motivation, description of technical concepts and Aspects for the customer.
					Outlook to the future.
					</td>
				</tr>

				<tr>
					<td><em>Biography: Employee of Software AG since 1999. From 1999 to 2000, system
					architect, responsible for the development of frameworks and customer solutions. Member
					of the Sales Consultancy since 01.2001.</em>
					</td>
				</tr>

			</table>

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

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

				<tr>
					<td class="general">
						<strong><a name="G6"></a>Commercial Solutions based on OpenOffice.org</strong>
					</td>
				</tr>

				<tr>
					<td>Erwin Tenhumberg <em>Product Marketing Manager, Sun Microsystems</em></td>
				</tr>

				<tr>
					<td>At trade shows and similar events the most frequently asked question is "What is the
					difference between OpenOffice.org and StarOffice?" This session will answer this question,
					but also give an overview about OpenOffice.org derivatives, Linux distributions, third party
					ISV integrations, and available add-ons. The goal of this session is to show that OpenOffice.org
					is more than just the open source office suite.
					</td>
				</tr>

				<tr>
					<td><em>Biography: Erwin Tenhumberg is the Product Marketing Manager for open source
					technologies in the Desktop Solutions Group at Sun Microsystems. Within this group he
					mainly focuses on the OpenOffice.org project. Erwin started working for Sun as a Systems
					Engineer doing pre-sales for various software and desktop products including the StarOffice
					office suite and the Sun Ray ultra-thin client. Before Erwin joined Sun he worked for various
					companies doing Java consulting, software development, desktop application administration,
					and end user support.</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>
