<html>
<head>
<title>Interview: Website Designers</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<h2>Interview: Website Designers</h2>
<p><a href="../lspintro.html">-Louis Suárez-Potts</a></p>
<p>2005-04-24</p>
<p>&nbsp;</p>
<p>The new website offers visitors a clear and straightforward view of OpenOffice.org, the product, community, and project. We expect that visitors will find the new homepage and site easy to use and engaging. The site design recognizes that the average visitor of OpenOffice.org is now more interested in downloading and using OpenOffice.org than in developing it, and though development is by no means forgotten, obtaining the application is now made easier.</p>
<p>I asked the lead designer, Maarten Brouwers, and architect, Christian Lohmaier, some questions on the new design; they kindly answered and their responses are below. Jacqueline McNally, the Lead of the Marketing Project, provided the overall vision and deeply influenced the content and layout of the homepage. Her responses will be included shortly. </p>
<p>But designing the new site was a group effort, and my thanks extends well beyond the designers. Special mention is merited by Miikka Leskinen for QA, Kay Schenk and Stefan Taxhet for coordinating work, and Matthew Wardrop, for his CSS skills, design insight, and good spirit. All have shown remarkable enterprise, ingenuity, and grace under pressure. It's been fun. </p>
<p>Among those who contributed importantly, in alphabetical order, thanks go to Emily Boyd, Nicu Buculei, Andrew Brown, Daniel Carrera (who first give out the call to make the site more efficient), Jean Hollis Weber, and to the entire Website Project. 
<p>The interview below was conducted via e-mail late in April. I edited only minimally.
<p>
<p><em>Design. What is the logic informing the design? What audiences are appealed to? And how has the design developed from an understanding of OpenOffice.org, as a source project, as a community, as a product?</em></p>
<p><strong>Maarten</strong></p>
<div class="indent">
  <p>With this new design we wanted the OpenOffice.org site to appeal more to new users. First we started with removing all junk from the homepage. There was in our opinion way too much information and places to go, which was rather scaring new users. OpenOffice.org 2.0 is almost ready for mass-adoption and therefore a user-friendly website is a must. The three buttons 'New User?', 'Native Language' and 'Download' should address the primary needs of most users.
    

  <p> Besides cleaning up the homepage the overall look of the site was addressed, for two reasons: getting it more inline with the 'style' of OpenOffice.org, and making it visually more appealing. Though the house-style of OpenOffice.org is not yet well defined, I believe the current website is a good improvement on the previous site regarding to visual style. We went for a fresh, blue and cool look with a little colour. </p>
</div>
<p><strong>Christian</strong></p>
<div class="indent">
  <p>The frontpage is now more end-user related. We tried hard to remove clutter, to make it easier to get where you wanted to go &amp; to draw the attention to the main navigation elements (the tabs at the top & the buttons). And of course we wanted a facelift.</p>
  <p> The page is meant as a, "Hello dear visitor - How can I help you?" instead of, "Here's the information - hope you find what you're looking for." </p>
  <p> The new frontpage is of course only one of many pages that will get redesigned. </p>
  <p> As to how this relates to OpenOffice.org as a community, an open-source product: we now have a tab called "Contributing". Many people are willing to take part but just don't know where to start. A helping hand is just one click away - it now is an integral part of the website. Although the contributing pages themselves existed before, they only were a link amongst many others. They really needed to be more prominent as OpenOffice.org always needs more contributors, more volunteers. </p>
  <p> OpenOffice.org as a product, an office suite, is given credit through the main contents: the abstract (OpenOffice.org is...), accompanied by the big download button and the links to the components' description. It is astonishing how many people still have not heard about OpenOffice.org. Those who visit <a href="/">www.openoffice.org</a> to find out should find this information right ahead, not buried somewhere. Since the description is very short, we added the "new user?"-button (and the relevant pages) that will give a more elaborate explanation about what OpenOffice.org is as a product, and what the community thing is all about. These pages will also give an overview of the various areas on the site (the different projects, support area, etc.). </p>
  <p>&nbsp;</p>
</div>
<p><em>The new design relies substantially on your architectural insight and on the technological tactics you have deployed. Project leads have more flexibility, now, in managing their left navbar, for instance. Can you tell me what you wished to accomplish in the new design? How is it easier for developers or users, for example?</em></p>
<p><strong>Maarten</strong></p>
<div class="indent">
  <p> In relation to the OpenOffice.org file format, which is standards based, we agreed that it was rather a contradiction that the website of OpenOffice.org didn't rely on standards, really. The suite itself is great in semantic markup, but the website itself didn't seem to need it. Especially for those interested in the techniques--and this was, in my humble opinion, a bad thing. So we started using more semantic markup where possible and using the 'appropriate' elements. This is nothing new though, and many (also popular) sites have gone this road before. </p>
</div>
<p><strong>Christian</strong></p>
<div class="indent">
  <p> The main (technical) goal was to provide standards-compliant XHTML-Transitional. At the same time Maarten was the driving force in getting rid of tables and using some other elements that give the contents a logical structure, not a layout (the layout is now defined in the CSS). </p>
  <p>Referring to the new way a project can define its left navbar, this makes is easier for developers since they no longer have to add a navigation element to every single html page. Now they can simply put a file with the desired links into their repository and the content is added automatically - very similar to a SSI that everybody was begging for. When changing a link the maintainers do not longer have to modify each single file - just updating one single file is enough. </p>
  <p> From the user's point of view, this means that a visitor of the various native-lang project can now find the default links in his or her native language and the links can appear in a more structured way (within the other links the project offers in its navigation). And they don't see links which are irrelevant to a particular project. </p>
  <p> What the left navbar will look like and what links it will contain is now up to the individual projects. </p>
  <p>&nbsp;</p>
</div>
  <p>My thanks again to the Website group. OpenOffice.org is evolving to accommodate more end users wanting only a commodity but keeps its roots firmly in  participatory ground, and the new homepage and site reflect that. Congratulations all. </p>
  <hr/>
  <p><a href="articles.html">Editorial Index</a>   
</div>
</body>
</html>
