<html><head>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>
<h2>Interview: Ed Peterlin and Dan Williams:<br>
  OpenOffice.org for Mac OS X </h2>
<p><em>2002-07-25</em></p>
<br>
<h4>Introduction</h4>
<p>The first Mac OS X port of OpenOffice.org (638c) was released at Apple's <a href="http://developer.apple.com/wwdc2002/">World 
  Wide Developer Conference</a>, on May 7. OpenOffice.org was there in strength: 
  we had a very popular booth and Ed Peterlin presented an exciting demonstration 
  of the build before an audience of Open Source developers. (More on this soon.)</p>
  
<p>In the months since then, the two community contributors primarily responsible 
  for the Mac OS X port, Ed Peterlin and Dan Williams, have substantially furthered 
  their work; although it is still a developer release, it now runs using OpenOffice.org 
  1.0 and can be immediately <a href="http://porting.openoffice.org/mac/ooo-osx_downloads.html">downloaded</a>. 
  It also, with some limitations, saves files and prints. The following is a very 
  slightly edited e-mail interview conducted over a few days last May. The build 
  Ed and Dan refer to in conversation is the older build, 638c. If you are curious 
  about what the updated port (1.0) does and does not do, Dan prepared an excellent 
  <a href="../about_us/pressfaq_ooo-osx.html">FAQ</a>.</p>
<br>
<h4>The People</h4>
  
<p>I have never met Dan Williams; but I did spend a lot of time during WWDC with 
  Ed Peterlin, and I would love to have the talent to put to paper his energy, 
  enthusiasm, and dedication to this project. Both Ed and Dan don't seem to sleep; 
  OpenOffice.org for Mac OS X is their hobby.</p>
  <br>
<h5>Ed Peterlin</h5>
  
<p>Ed's day job is at <a href="http://www.biopac.com">BIOPAC Systems, Inc.</a>, 
  where he is responsible for Macintosh development. In his words: "I write 
  software for displaying and analyzing physiological signals, such as heartbeat 
  and muscle response, that are acquired from our MP hardware." But what 
  drew him to OpenOffice.org?</p>
  <p>"I grew interested in OpenOffice.org through using 
    StarOffice on Solaris boxes a few years ago. Having no other office solution 
    for a Solaris machine, I became quite impressed with its capabilities and 
    usability. Even at BIOPAC I've used OpenOffice.org when we ran out of licenses 
    for MSFT Office but had to read technical documents that were written in Word. 
    When I heard an OS X port was released to the open source community, I felt 
    interested in bringing this solution that had proven so useful to me in the 
    past to one of my favorite platforms. I joined the OpenOffice.org project 
    the weekend after I got a machine capable of running OS X, around July-September 
    of last year.</p>
  
<p>"I became interested in Macs as an extension of the old Apple IIe, my first 
  computer. I was in an Apple-based school system, and after I outgrew my IIe 
  a Mac was the next best step. Not to mention that at the time I could get a IIe emulator 
  card and still play my favorite video games."</p>
 <br>
  
<h5>Dan Williams</h5>
  <p>"By day I am an undergraduate Anthropology major 
    specializing in Archaeology (screw Cultural [Anthropology], Archaeology is 
    where the real fun is), which is partially where I get the time to work on 
    OpenOffice.org. I have fun making databases that store and analyze spatial 
    data, and have an active interest in Geographic Information Systems and developing 
    their potential in Archaeology.</p>
  <p>"After hearing a lot about StarOffice, trying it 
    out on Linux, and seeing it as really the only viable alternative to Microsoft 
    Office on any platform, I became interested in OpenOffice.org. I looked at 
    it, said, This is cool. It had everything I thought should be 
    in an office suite, and I decided that MS Office wasn't anything special after 
    seeing how good StarOffice was. I thought that, since it wasn't on Mac and 
    I had Unix and Mac OS programming experience, I'd help it get there.</p>
  
<p>"I got my start with an Apple IIe back in early elementary school, graduated 
  to a Mac LCIII, bought Think C back when it <em>wasn't</em> a Symantec product, 
  and taught myself Mac programming though books. It was amazing that I could 
  create programs that did stuff like professional programs did. From there I 
  kept buying copies of CodeWarrior and keeping up on new Toolbox stuff. When 
  I first used Unix I was impressed, but the Mac was still better to use. When 
  Mac OS X came along, I got very excited because of the power of its Unix base. 
  And because StarOffice was on Unix, it could be on Mac OS X too."</p>
  
<br>
<h4>About the Port</h4>
  
<p><strong>Ed:</strong> "The build [638c for Mac OS X] was the first of many milestones 
  that the Mac OS X porting effort reached. For the last year, everyone working 
  on the Mac OS X porting project has been staring at error messages coming out 
  of the development tools, and the 638c developer build represented the first 
  time we'd been able to get OpenOffice.org to launch.</p>
  <p>"I have been impressed with just how much of the 
    software appears to be functional, a real testament to the engineers who originally 
    designed OpenOffice.org with the foresight that it would be moved into new 
    platforms. Even while watching people play with the demo machine at WWDC I 
    was continually amazed to see just how much works. That said, there's still 
    quite a ways to go.</p>
  
<p>"Our Quartz native graphics layer is not yet complete, so we can't run the first 
  build on Mac OS X without additional software to allow us to use the X11 graphics 
  layer. We are still lacking several key features, such as printing, and have 
  issues with saving files. Other features such as the ability to use Java code, 
  Mozilla LDAP support, and play sound during presentations are also broken. There's 
  a whole litany of missing features on our <a href="http://porting.openoffice.org/mac/roadmap.html">roadmap 
  webpage</a> that need to be implemented before we reach 1.0.</p>
  
<p>"When 1.0 is released [it's just been <a href="http://porting.openoffice.org/mac/">released</a>&#151;LSP], 
  we'll have one of the best office suites available for Darwin and Mac OS X. 
  It will be feature complete with OpenOffice.org 1.0 on the other first tier 
  platforms, and it will still look like OpenOffice.org does on other platforms. 
  After that, we want to make the best <em>Mac</em> office suite possible for 
  Mac OS X. I hope we'll have enough developers to begin including the Aqua look 
  and feel, use sheets and drawers, implement collapsible toolbars, and perhaps 
  even integrate with QuickTime and other features of OS X. This will help us 
  to truly deliver a great Mac OS X experience without sacrificing the familiarity 
  and power OpenOffice.org brings from its Windows and Unix heritage."</p>
  
<p><strong>Dan:</strong> "First, the Aqua VCL build needs to actually compile, 
  then we need to fill in the missing implementations. Next, the look and feel 
  needs to be customized to match the Mac OS X user experience and the nuances 
  that Mac users have come to expect. I believe that that's where the most work 
  lies, and that's where the most fun will be had: watching a real office suite 
  take on an Aqua L&amp;F [look and feel] and come out usable and shining, a pleasure 
  to look at and use.</p>
  
<p>"But not to forget the X11 VCL build either: There are no full office suites 
  available for Darwin, an OpenOffice.org will be the best one when we're done 
  with it. I don't think either of these will happen for months, but we're working 
  toward these goals, having a lot of fun and frustration getting there, and feeling 
  that we're contributing something that will be much used and greatly appreciated."</p>
  
<br>
<h4>The Group</h4>
  
<p><strong>LSP:</strong><em> How many of you were working on the project?</em></p>
  
<p><strong>Ed:</strong> "There were about ten overall contributors to the OS X port 
  since before it was open sourced. All were volunteers from the community and 
  played around with OpenOffice.org in their spare time, mostly looking into how 
  to fix up the errors that made us unable to compile the project. Three developers 
  were active during the few months leading up to our initial milestone release."</p>
  
<p><strong>Dan:</strong> "Like Ed said, there were about ten people in various levels 
  of participation on the project. When it was released, some people took a stab 
  at it, but there wasn't a critical mass of committed enough people to move it 
  forward. I guess they got discouraged and probably put OpenOffice.org aside 
  for a while. Then others came along and began to slowly move forward (and I 
  mean slowly) with the build. Once a couple of people had an idea of what was 
  going on and how to get things going, that attracted more people. Along the 
  way a number of small but significant successes (X11 build, VCL bug in 10.1) 
  contributed hope and the sense that <em>something</em> was happening."</p>
  
<p><strong>LSP:</strong> <em>How did you arrange work?</em></p>
  
<p><strong>Ed:</strong> "We ended up arranging our work just through contacting 
  each other by e-mail and instant messaging. We were all kind of doing the same 
  thing, fixing build errors, until the final push when we just decided what we 
  wanted to do: come up with installers, write frequently asked questions, etc. 
  With only a few people, it was relatively easy to find hard lines between tasks &#133; 
  one person to author it (or program it), and another to proof it (or test it). 
  When more people join the project, however, it will be essential to use a good 
  collaboration tool such as CollabNet provides. Not only does it provide a good 
  way of disseminating information outside of a core group, it provides historical 
  archives and perspectives. Without the ability to see what had been written 
  and coded between April and September, I wouldn't have been able to get up to 
  speed on the project as quickly as I have."</p>
  
<p><strong>Dan:</strong> "I think the biggest problem that faced the project up 
  until about February 02 was the organizational aspect. There was no one person 
  in charge of the port and so no one had a sense of organization. Everyone felt 
  like they were about the only person working on the thing and that there was 
  so much to do. But now with Ed being the nominal project head, there's more 
  of an idea of how the project is going and what's going on.</p>
  
<p>"There is no formal to-do or responsibility list. People basically just volunteer 
  to work on something. This of course means there is duplication of effort in 
  some areas, but there are still not that many people working and there's lots 
  to do. Besides, more people looking at a piece of code or a build error means 
  more people with ideas on how to fix it. During the ramp-up to WWDC there were 
  about 4 or 5 people who were part of the core Mac OS X/Darwin team who were 
  working on stuff and a couple of people inside Sun [and CollabNet] who were 
  on the marketing part. It was hectic and a bit unorganized but it was a lot 
  of fun and people just kept stepping up to make sure the job got done. Stuff 
  gets done because people volunteer to do it, not because responsibility gets 
  doled out. And because they volunteer, I think they have more of an active interest 
  in getting it done, and are more likely to do a better job, because they want 
  to. Since there were only a couple of people working, it was fairly easy to 
  organize stuff informally, but this will get harder over time as more people 
  join."</p>
<p><strong>LSP:</strong><em> And how was the group formed?</em></p>
  
<p><strong>Ed:</strong> "Things formed just from people looking at the websites 
  available on OpenOffice.org and through e-mailing each other on the dev@porting 
  list. There was never any official organizational effort, just a bunch of guys 
  who were interested enough to plod through the very raw and incorrect original 
  material up on the websites, correcting it for each other, and starting to help 
  others get on board quickly. We've continued that style of effort, and hopefully 
  we're making the entry curve for the project a lot easier for newcomers."</p>
  
<p><strong>Dan:</strong> "Like Ed says again, people just got interested, made contact 
  with other people who were also interested, and started asking questions. Those 
  with some answers to give stepped up, and people stuck with it. Those who tried 
  and didn't stick with it probably got discouraged because there was no critical 
  mass of people to work out things with&#151;not enough people who knew what was 
  going on. We hope they come back now: we need them.</p>
  
<p>"There was also a big discussion earlier this year about whether to fork a separate 
  project for the OS X port or whether to keep it in the porting one. We could 
  have had a separate mailing list just for Mac OS X, but we decided to stick 
  within the porting project since that was easiest and guaranteed easier access 
  to other developers who knew what we did not (i.e., general OpenOffice.org stuff 
  and not just Mac)."</p>
  
<p><strong>LSP:</strong> <em>Towards the end, the group was working tightly and 
  somewhat in secrecy; at least not all of the communications were out in <a href="mailto:dev@porting.openoffice.org">dev@porting</a>. 
  What effect did that have on your group?</em></p>
  
<p><strong>Ed:</strong> "A lot of issues that we faced came back to a lack of time. 
  Being able to simply IM [instant message] each other when we were available 
  or communicate off-list allowed us to really concentrate on what we needed to 
  do: code. It unfortunately takes time to answer people's questions on mailing 
  lists and help newcomers to the project, and we simply didn't have the time. 
  As more people join us, we'll be able to divide our efforts so someone can spend 
  the time to continually update our website and respond to the community mailing 
  lists. With only two to three people working two hours a day in varying states 
  of sobriety and trying to hit a major deadline, expending any effort away from 
  coding would have not allowed us to move with such speed."</p>
  
<p><strong>Dan:</strong> "As of a couple weeks before WWDC, all the important traffic 
  about the OS X/Darwin build was off-list. It was kind of unfortunate because 
  those few people that did post on dev@porting with questions and who were not 
  on the private list didn't know they were out of date, or would be in a week. 
  We couldn't really answer their questions. Anyway, I think the off-list discussions 
  and communication, while not the best for the port as a whole, did enable the 
  members to get the WWDC build working in a very quick and efficient manner with 
  a minimum of static. Plus, the whole press thing, where we could not afford 
  to have the general Mac community get all worked up over a <em>developer</em> 
  build and then get subsequently let-down when they figured out it actually <em>was</em> 
  a developer build. I think the off-list list also enabled the people involved 
  to get to know each other better and to work better as a team to get what needed 
  to be done."</p>
  
<p><strong>LSP:</strong> <em>How long did it take your group to get to this point?</em></p>
  
<p><strong>Ed:</strong> "We did not have a reproducible build process until towards 
  the end of march, and a major bug preventing the OpenOffice.org Writer module 
  from launching wasn't fixed until about the middle of April. It's taken since 
  last April to get this far."</p>
  
  <p><strong>LSP:</strong> <em>What was the main stumbling block?</em></p>
  
<p><strong>Ed:</strong> "Technical difficulties present within Mac OS 10.0.x. When 
  Apple released 10.1.x with dual level namespaces, a big roadblock was removed."</p>
  
<p><strong>LSP:</strong> <em>Were there periods when it seemed this effort would 
  fall apart?</em></p>
  
<p><strong>Ed:</strong> "When I started to see the compiler fail on certain 
  files that worked on gcc on other platforms, I started to think that it might 
  not be possible to make headway until Apple fixed the compilers to not segfault. 
  Thankfully a few clever people were able to find workarounds for the faults 
  in the tools. The next set of development tools from Apple should be a lot better 
  for C++ programs and should solve those problems that we didn't have the expertise 
  to solve easily."</p>
   
<p><strong>LSP:</strong> <em>Where would you suggest people start?</em></p>  

<p><strong>Ed:</strong> "I would suggest that everyone start by downloading the 
  pre-alpha milestone binary and start playing with it. :) The amount of time it 
  takes to get up to speed with the initial compile is a while, but I hope that 
  seeing how good the product can be will convince people that the effort is worth 
  it. Also, end users should start there so they can witness what we may be capable 
  of in the future.</p>
  
<p>"The next step is probably to read the <a href="http://porting.openoffice.org/mac/roadmap.html">roadmap</a> 
  for the port. It shows you (roughly) where we've been, where we are, and what's 
  left to go. Again, the roadmap is just a reflection of what's been discussed 
  by the community of both Mac OS X and non-OS X porting developers in the past 
  and is always up for commentary or change. Perhaps if we get enough people to 
  help we could even start putting potential dates of completion on it as well &#133;</p>
  <p>"After getting a compile started from reading the 
    build instructions, it's probably best to start reading some of the white 
    papers describing the architecture of the program. It's quite large and is 
    difficult to get a grasp on without the documentation. Also, it'll help get 
    people familiar with the terminology and acronyms thrown about on the dev 
    lists and other sources of information.</p>
  
<p>"There are links to the binary installer at the top of the <a href="http://porting.openoffice.org/mac/">Mac 
  porting page</a>, and there's a pointer to the white papers at the bottom."</p>
  
<p><strong>Dan:</strong>"I'd suggest they sign up with the <a href="http://porting.openoffice.org/">Porting 
  project</a>, and <a href="mailto:dev-subscribe@porting.openoffice.org">subscribe</a> 
  to the <a href="mailto:dev@porting.openoffice.org">dev@porting</a> list, then 
  follow the build instructions; and most important, <em>ask questions</em> when 
  things don't work, so we can help. If they just get discouraged and walk off, 
  that doesn't help anybody. But if we can help people see that things can work, 
  then great. We need the help.</p>
  <p>"I'd like to thank everybody who helped of course, 
    but mention Ed specially, because he's the nominal head of the project and 
    someone had to do it. We can all whine to him when things don't work out and 
    ask him to make it better. But then he'll just tell us to deal with it ourselves 
    and report back how we did."</p>
  
<p>The new version, OpenOffice.org 1.0 for Mac OS X is <a href="http://porting.openoffice.org/mac/ooo-osx_downloads.html">available</a> 
  now. Thanks Ed, Dan, and the rest of the <a href="http://porting.openoffice.org/">Porting 
  Project</a>.</p>
  
 <hr>
 <p><a href="index.html">Other Articles</a></p></body>
</html>

