<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_general.html,v 1.12 2004/08/27 09:01:43 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 - Friday</h2></td></tr>
	</table></td></tr>

	<tr>
		<td>
			<table width="100%" id="G7" name="G7" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="general"><strong><a name="G7"></a>
						Migration Paths to OpenOffice.org
						</strong>
					</td>
				</tr>
				<tr>
					<td>
					Lars Piepho <em>probusiness AG</em>
					</td>
				</tr>
				<tr>
					<td>
						<p>
						The Session describes procedures of migrating small and
						middle-sized companies to OpenOffice.org,
						with focus on migrating from Microsoft Office.
						Including integration of OpenOffice.org with phpGroupWare
						for forms,
						practical experience and pitfalls in real life. 
						</p>
					</td>
				</tr>
				<tr>
					<td id="G7b"><p><em>
						Lars Piepho works at probusiness AG since 2001. Main tasks
						are OpenSource
						software consulting and developement. Special experiences
						in OpenOffice.org and phpGroupWare.
						</em></p>
					</td>
				</tr>
			</table>

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

			<table width="100%" id="G8" name="G8" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">

				<tr>
					<td class="general"><strong><a name="G8"></a>Office Suite Market in China and CS2C's Practice</strong>
					</td>
				</tr>
				<tr>
					<td>Mr. CHEN Yuhao <em>Neoshine Office Technical Manager</em>,
						Mr. ZHANG Yongjun <em>Neoshine Desktop Product Manager</em></td>
				</tr>
				<!-- tr>
					<td><p></p>
					</td>
				</tr>
				<tr>
					<td id="G8b"><p><em>Biography: </em></p>
					</td>
				</tr -->
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
			<table width="100%" id="G9" name="G9" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="general"><strong><a name="G9"></a>
					OpenOffice.org and the Federal Public Administration</strong>
					</td>
				</tr>
				<tr>
					<td> <em>Egon Troles</em></td>
				</tr>
				<tr>
					<td>
						<p>
						The talk is done on the
						behalf of the Coordination and Advisory Board of the
						Federal Government of Germany.
						This talk shows, how the federal public adminstration is using
						OpenOffice.org.
						It also gives a view of the experience in migrations
						and tells where the problems for the users are to migrate.
						Usability and acceptance are very
						important for users, but also the communication with others
						in the federal
						public administration. Therefore the focus of this talk is,
						how to make it
						easy to migrate and showing the problems which could be solved
						by the
						developers. A short overview on the
						european situation of open document formats is also given.
						</p>
					</td>
				</tr>
				<tr>
					<td id="G9b"><p><em>
						Egon Troles was a member of the Coordination and Advisory Board
						of the Federal Government (KBSt) until 2002. In this time
						he was the project leader
						of the Internet Backbone Project, which is a part of
						the Federal Republic's
						Government Network between Berlin and Bonn. He also was one
						of the authors
						of the KBSt-Letter 2/2000, which proposed
						Open Source Software for the
						public adminstration.
						Now he is working at the Federal Data Protection Commissioneer
						in the
						Department of technological dataprotection. As a former
						colleague of the Coordination- and Advisory Board he is
						often working on the strategical
						aspects of Open Source Software for the public administration.
						He is also a
						member of the european expert group on open document formats.
						</em></p>
					</td>
				</tr>
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
			<table width="100%" id="G10" name="G10" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="general"><strong><a name="G10"></a>OpenOffice.org at the "French Institute of Statutory Auditors"</strong>
					</td>
				</tr>
				<tr>
					<td>Eric Barroca <em>CEO, Indesko</em></td>
				</tr>
				<tr>
					<td><p>OpenOffice.org at the "French Institute of Statutory
					Auditors": a case study in building
					OOo-based business applications and in integrating OOo with a CMS / Collaborative Platform.</p>
						<p>As part of the CNCC (Compagnie Générale des Commissaires aux comptes – French 
						Institure of Statutory Auditors – CNCC is well-know in the “audit world”) extranet 
						project led by Unilog and Nuxeo, Indesko has developed the following functionalities:</p>
						<ul>
							<li>"Audit folders": an application that manages Calc spreadsheets created by
							auditors during their missions (statutory audits) on location, then provides on-line
							diff / merge of Calc spreadsheets in a visual way (using XMLDiff and XSLT), enables
							collaboration for the audirtors' team (versionning, forums, indexing, etc.), and creates
							financial reports.</li>
							<li>Integration of OOo with Nuxeo CPS, an open-source Zope-based CMS developped by
							Nuxeo. This includes "Edit in Place", SSL (client certificate authentication) and
							PKI support for better security. UNO Pythons modules provide those features into OOo.</li>
							<li>A full XML transformation chain for publishing books (accounting norms, law
							comments, books...) using OOo as a DocBook XML editor. The full chain is :
								<ol>
									<li>Authoring with OOo and collaboration using CPS's features. Contributors
									author OOo documents and manage them in the collaboration portal. Documents
									can follow an dynamic approval workflow (cascading delegation and approbation),
									and are always securely and surely sent to the server from OOo, using SSL
									Client Certificate Authentication.</li>
									<li>Live transformation and validation of OOo document into Docbook XML.</li>
									<li>Docbook is transformed into HTML (for direct on-line publishing with
									CPS) and PDF (for printing)</li>
								</ol>
							</li>
							<li>Creation of a custom OOo distribution for several thousand users at the auditors
							firms (this includes : custom UNO modules, custom macros, custom templates, easy
							and packaged installation process, etc.).</li>
						</ul>
					</td>
				</tr>
				<tr>
					<td id="G10b"><p><em>Biography: Eric Barroca is CEO of Indesko and project and sales manager
					at Nuxeo. He managed some large project using Nuxeo CPS (French Interior Ministry, French
					"Justice" Ministry) or OOo (CNCC). He author of several technical papers for OOo marketing
					and promotion.</em></p>
					</td>
				</tr>
			</table>

			<p><a href="friday.html" title="Agenda for Friday">Back</a></p>
			<table width="100%" id="G11" name="G11" summary="" border="1" cellpadding="8" cellspacing="0" bordercolor="#000080">
				<tr>
					<td class="general"><strong><a name="G11"></a>Digital Signatures and other security options</strong>
					</td>
				</tr>
				<tr>
					<td>Malte Timmermann <em>Sun Microsystems, Inc.</em></td>
				</tr>
				<tr>
					<td><p>Digital Signatures are an important feature for Authentication. They can be used to verify
					if a document really comes from a certain author and that the content was not modified. This
					information can also be used to configure which macros to trust and which not. OOo 2.0 will
					introduce Digital Signatures based in W3C XMLDSIG recommendations.</p>
					</td>
				</tr>
				<!-- tr>
					<td id="G11b"><p><em>Biography: </em></p>
					</td>
				</tr -->
			</table>
      </td>
    </tr>
  </table>

  <hr />

  <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>
