Excited about EclipseCon Europe

Ten years ago, we were burning the midnight oil getting Eclipse 1.0 ready to release.  I offer you proof

Me stuck behind server rack. Yes, I'm wearing COWS shirt.  Please don't judge me.

Today, we're working hard to polish our presentations as we celebrate ten years of  Eclipse at EclipseCon Europe.  I'm excited to have the opportunity to attend EclipseCon Europe, this will be my first time :-) 

I've been preparing two presentations over the past few weeks.  The first one is called Migrating to Git: Rethinking the Commit.  Here, I'll talk about the process we used to convert our large and historic CVS reposository to Git, the problems we encountered, how our development processes changed, and what advice we can offer other teams that are contemplating this migration.

Image ©venegas, http://www.flickr.com/photos/venegas/5549123/ licensed under Attribution-NonCommercial-ShareAlike 2.0 Generic (CC BY-NC-SA 2.0)

Image ©spool32, http://www.flickr.com/photos/spool32/5045502202/ licensed under Attribution-NonCommercial-ShareAlike 2.0 Generic (CC BY-NC-SA 2.0) 



The second talk is a light-hearted look back at the past ten years.  I received an email from EclipseCon Europe this morning that stated.  "After the Stammtisch, a couple of long-time Eclipse enthusiasts present Has it Really Been 10 Years?."  Long-time enthusiasts?  Okay, that made me feel old.  Anyways, in this talk John Kellerman and I look back at the the last ten years and discuss what what we expected when Eclipse was released as open source, the response we received, what mistakes were made, what surprised us.  Fair warning: I have uncovered some embarrassing pictures from our past Eclipse family.  I'll be using this occasion to showcase them.  If you have any interesting pictures to share, email me and I'd be happy to include them :-)   My understanding is that a Stammtisch involves beer so I think people will be in the right mood when they walk into the talk.

Last but not least, I invite you for to go for a run or walk each morning at 7am.  We'll meet in the lobby of the Nestor hotel.  Sign up for EclipseCon exercise here! 

See you soon!

Read more...

A history of lizard wrangling and other software stories

I've been thinking a lot lately about open source history.  I'm in the midst of preparing material for a presentation that John Kellerman and I will be giving at EclipseCon Europe about the history of Eclipse. Last week an interesting video crossed my twitter feed.  It was a talk by Mitchell Baker on the history of Mozilla.  Mitchell is the Chair of the Mozilla Foundation and Mozilla Corporation and has been involved in this community for many years.  Her title is Chief Lizard Wrangler.  That's the best job title I have ever heard.  Well, being called an astronaut would be fun too but you get the idea.  According to Wikipedia, she's a also skilled trapeze artist.  I like learning about people with interesting hobbies.




In the video, she talks about the history of  Mozilla, which started in 1998. She describes the tension between Netscape the corporation and Mozilla the community.  For instance, the belief in the Mozilla community that commit rights should be earned and voted on by your peers, not just assigned based on your employer.  It's a really interesting to learn about the conflict in those early years at Mozilla and how they worked so hard with very few resources to be where they are today.

One of my favourite lines from the talk is that "Technology alone does not change people's lives.  Our opportunity in the browser is to have a product that touches people." Also, she states that the problem with a lot of open source projects is that they are irrelevant to the marketplace and don't treat their users very well.  For instance, calling a user stupid isn't going to make their life better.  "You need to make a product that is elegant and beautiful and powerful under the covers but that people love."  Mozilla has a bit of a different outlook that the Eclipse community because their flagship product Firebox is used by everyday consumers.  Eclipse components are consumed by developers in the form of open source packages that the coordinated release provides, but at the same time many people consume components in commercial products that build upon our open source offerings.

Some other memorable lines "UI is always the most contentious issue".  Well, at Eclipse we never argue about UI.  Wait....hmm..maybe...this bug has a few contentious comments.....

This talk really resonated with me.  Eclipse and Mozilla are two well known open source communities with different histories but ultimately both are very successful.  I highly recommend taking the time to listen to it.

Happy Ada Lovelace Day from Ottawa!

Read more...

Hacker History

I recently read the book hackers: heroes of the computer revolution by Stephen Levy.  It looks back at the cast of characters that were involved in the early years of computing, starting in the late 1950s until the 1980s. The word hacker in this context doesn't mean someone that was breaking into machines for malicious intent, but rather someone who is breaking new ground in software and hardware.  The book is divided into three sections.  The first third of the book concentrates on people writing software at university labs such as MIT, the second third describes people making their own hardware in Silicon Valley computer clubs in the 1970s, and the final third looks at the beginnings of the PC game industry in the 1980s.

Interesting things I learned.

From xckd

• LISP was invented in 1958.  Old school.
• People used to single-handedly write a game and and then sell it to a game company such as Broderbund or Sierra On-line for a royalty on sales.  Like 30% of sales. A best selling game could make a young developer very very rich in a short period of time.
• Silicon Valley used to be called Silicon Gulch. Silicon Valley sounds classier.
• Bill Gates sold an early version of BASIC to a computer club which then copied it and distributed it to their members for free.  He then published a letter in a club newsletter that stated "As the majority of hobbyists may be aware, most of you steal your software."...."Who can afford to do professional work for nothing?"   A young Bill Gates writing about piracy in 1975. History repeats itself.
• Early hackers spent days, weeks even months on end in the lab without showering.  They also didn't date much.  Coincidence? No.
• The process to bring the Apple II to market and the interactions between Steve Jobs and Steve Wozniak were pretty interesting.

The book also talks about  the "hacker ethic", which underpins many things that we see in current open source communities today.  From the book

"Information should be free.
Mistrust authority--promote decentralization.
Hackers should be judged by their hacking, not bogus criteria such as degrees, age, race or position.
You can create art and beauty on a computer.
Computers can change your life for the better".


This book looks at the technical advancements that these hackers implemented, but is also interesting to see the culture as these nascent communities evolved. Also, it also describes the first computer conferences and magazines. It's also interesting to note the incredible passion and effort that these hackers dedicated to their  professional endeavours often had negative repercussions in their personal lives.

Anyways, if you are interested in reading about early computing history, this is a great book.   The first computer that my Dad (yes it runs in the family) brought home in the early 1980s was an Osborne , so I felt rather nostalgic reading about the this time period.

Source wikipedia

Read more...

Busting Build Myths

Who doesn't love Mythbusters? It must be great to wake up every morning and go to work in a fantastically equipped lab, build things and maybe set off a few explosions.  A dream job.

Unfortunately, my lab is filled with aging build machines, not cool toys.  When a build explodes I have to pick up the pieces and make it work again.  I've never been invited to the White House to talk science while sporting a snappy beret either.

Source Wikipedia: Washington Post blog, credit given to The White House/Chuck Kennedy, The White House/Chuck Kennedy

There are a few myths surrounding builds I'd like to bust.  I'll use the only tool I have available to dispel them, my keyboard:


1) My six bundle build is easy.  Thus your build is easy too.  There is a big difference between building a few bundles and building products, p2 repositories, API tests, tens of thousands of JUnit and performance tests for many platforms. Is running an Apache server in your basement the same as running Slashdot?  No. Builds are the same. Scalability issues and complexity.

2) Building with X will solve all your problems. Changing to a different build technology to compile and package your bundles can solve a lot of problems if it has been tested fully and works for all your requirements.  But there's a cost to migration.  To working out all the bugs and corner cases.  Is it worth the transition?  Only time will tell.  The more complex the build, the higher the cost of migration.  Yes, it would be wonderful if we could all run our builds the same way at Eclipse to help our consumers.  But this requires a considerable time investment to ensure that everything works.  As well, it means forgoing work in other areas to facilitate this transition. It's a tradeoff.

3) Once you get your build working, you never have to change it.  As my previous post described, build scripts evolve in concert with the code base. Constantly changing.  More code, more tests, more build gymnastics.  Building software is like owning a house.  You can try to to forgo all maintenance to save money, but your risk long term damage from broken pipes, a leaky roof or mice as the building deteriorates.

Homeowner forgot to visit Home Depot

Image ©graywolfx47, http://www.flickr.com/photos/graywolfx47/4308623603/sizes/z/in/photostream/licensed under Attribution-ShareAlike 2.0 Generic (CC BY-SA 2.0)  

4) Nobody in needs to understand how the build works, they just need to push a button.  That's great. Until the day before a release when your build fails with a cryptic message about unresolved dependencies.  And you have no idea how to fix it.  And neither does anyone else on the team.

5)  Release engineers are unskilled monkeys.  On the weekend, I attended the Software Developer's Summit here in Ottawa.  Interesting conference and it was great to meet some new  people. In the afternoon,  there was a meeting to discuss the long term build support with Eclipse foundation staff and other interested parties.  The term "monkey" was used by several participants as a colloquial expression for a release engineer.  I don't think it meant to be a malicious expression but at the same time, I found it interesting.  Many developers have limited knowledge of how builds work, to them it's a big black box.  Monkeys.  Big black box. Hmmmm. This sounds familiar.

Let's pretend these apes are monkeys.

Source: Wikipedia. Interpretations of 2001: A Space Odyssey

Since we release engineers understand how the black box works, maybe we're not the monkeys :-)

What other build myths are out there?

Read more...

Research, Release Engineering and ROI

I recently read some academic papers that quantify some release engineering practices in open source communities.  Very interesting.

The first one, "An Empirical Study of Build Maintenance Effort" (PDF), looks at how the time spent maintaining the build impacts the developers in a project.  It examines build coupling which refers to the how often changes in source code require changes in build code, as well as build ownership, which is the proportion of developers on the team who are responsible for maintaining the build.  The projects studied were ArgoUML, Hibernate, Eclipse (SDK), Jazz, GCC, Git, Linux, Mozilla, PLlot and PostgresSQL.

Here are some snippets I found interesting in this paper.  Note that when they refer to "Eclipse-core" they mean the Eclipse project's build. In this paragraph, they are talking about build coupling and how to reduce it

"In Eclipse-core, the coupling is reduced to 16% and in Jazz the observed coupling is a mere 4%.  Eclipse-core and Jazz both leverage the automated Eclipse Plugin Development Environment (PDE) build technology. ..... Since the developer must only maintain the high-level build.properties file (via the IDE), the daily build maintenance is reduced".

Thank you PDE family.  Dynamically generating Ant scripts at build time to compile and package our bundles makes us look good when compared with other open source projects.

"Other researches have found that the Linux build engineers have spent a considerable amount of time to make their build system as simple as possible for developers, as the expense of a very complex and hard to maintain core build system machinery. "

People always assume that writing software is hard, but for some reason building software should be easy. Build systems are complex beasts and obfuscating the complexity for the user is just as difficult as it might be when writing a full scale application. Writing good software is difficult, and so is constructing an elegant and effective build system.  It's just a different skill set.

 "Up to 79% of source code developers and 89% of test code developers are significantly impacted by build maintenance, yet investment in build experts can reduce the proportion of impacted developers by 22% of source code developers and 24% of test code developers."

So it looks like if you hire a release engineer and the productivity of your developers will increase.  You would buy a new machine to make the build faster, why not hire a fantastic release engineer and make the build better? The numbers indicate an great return on investment. 

Building complexity

Image ©algonquin_college, http://www.flickr.com/photos/algonquin_college/4971004199/in/photostream/ licensed under Attribution-ShareAlike 2.0 Generic (CC BY-SA 2.0)  


The second paper of is interest is entitled "The Evolution of Java Build Systems" (PDF). 

Again it looks at open source build systems that use either Ant (ArgoUML, Tomcat, JBoss, Eclipse-core) or Maven (Hibernate and Geronimo). The authors find that as the number of source lines of  code being built (SLOC)  is strongly correlated with the number of build lines of code (BLOC).

"Similar to Lehman's first law of software evolution, build system specifications tend to grow over time unless explicit effort is put into refactoring them."

and

"The Halstead complexity of a build system is highly correlated with the build system's size (BLOC), indicating the BLOC is a good approximation of build system complexity".

Lots of build code means increasing complexity.  If you are only building a few bundles, your build is easier to understand.  Makes sense. 

From their analysis, they concluded found that both Ant and Maven based builds evolved in similar fashion.

I like this sentence

"Despite the crucial role of build systems and their non-trivial maintenance effort, software engineering research rarely focuses in them".

I'd like to thank the authors for conducting this research and look forward to reading more in the future.  Build systems are complex systems and I welcome the efforts of these researchers to quantify way they can be improved. And it's extra special when they look at the projects that we work on every day!

References:
It will never work in theory
Queens University Software Analysis and Intelligence Lab

Read more...

Open source: She loves you, She loves you not

Working in an open source community is great, but there are also some disadvantages. From my admittedly narrow world view as a committer working in the Eclipse community as an employee of a large corporation, here are some of my observations.

Image ©emzee, http://www.flickr.com/photos/emzee/162362897/sizes/z/in/photostream/ licensed under Creative Commons by-nc-sa 2.0  



Things I love about working in open source

1. The people you meet are amazing and enthusiastic.   It's is a privilege to work with such a group of talented and thoughtful people.
2. Instead of non-disclosure agreements, we're free to talk about everything we work on.  Since everything is open, there are tremendous learning opportunities.  This inherent openness  means university researchers write papers about our work. Interesting!
3. Open source software is used by our consumers in unique ways.  When Jeff Norris gave his keynote at EclipseCon 2010 on how Eclipse was used to monitor robots on Mars, it was extraordinary to think that we as a community had contributed to something that was literally out of this world.  And when he said thanks to the committers during his talk, it was a very proud moment for us all.  There are many other examples of ways in which Eclipse is used to extend our knowledge of the world(s) around us.

Image ©owlbookdreams, http://www.flickr.com/photos/owlbookdreams/3721505610/ licensed under Creative Commons by-nc-sa 2.0  


Some things I don't love about working in open source

1. Many people complain but don't contribute. They consume the code we craft, complain about how its written, but are loathe to roll their sleeves up and write a useful patch.
2. We are constantly starved for resources, whether it be people, or new hardware.  There are too many bugs and not enough days :-)
3. My gender is an outlier in our community.

Ten years ago this week, I started working in at a small company called Object Technology International (OTI) as a system administrator.  I was asked by Jeff McAffer to install a server called dev.eclipse.org that would act as a CVS and bugzilla server for a project that they were going to open source called Eclipse.  I said something like "Open source, that's great.  Just like Linux".  To which Jeff replied along the lines of  "Well, I don't think it will be as popular as Linux, but we'll see what happens".  And the rest as they say, is history.

What do you love about working in open source?

Read more...

Kill Build: Vol. 1

Here are some of the ways I've seen a build killed during my years as an Eclipse committter.


1.  Lightning. Ottawa has tremendous thunderstorms in the summer.  What also happens during the early summer? Our coordinated release.  One summer, a transformer next to our office was hit by lightning.  Boom.  No power for about 12 hours. Bye bye build.

Image © ViaMoi, http://www.flickr.com/photos/viamoi/3338093351/ licensed under Creative Commons by-nc-sa 2.0  

2.  Ice.  The air conditioner in our lab filled with ice and ceased to function. The machines in our build lab then overheated and shut down.

3.  Flood: Our lab's air conditioner leaked the resulting water and flooded the lab. The build was relegated to a watery grave.

Image © thirsk, http://www.flickr.com/photos/thirsk/840616475/ licensed under Creative Commons by-nc-sa 2.0   

4. Random loss of power.  A committer plugged in a space heater in her office which tripped a circuit breaker and killed the power in our build lab. Or the total and intermittent loss of power from the Ottawa Hydro.  In the end, the results is the same: a dead build.

Image © ViaMoi, http://www.flickr.com/photos/viamoi/3339707547  licensed under Creative Commons by-nc-sa 2.0   


5.  Hardware self-destruction.  The eclipse foundation's power supply for a disk array sparked and brought down the switching gear. Dying switches, UPS's and drives have also wrought havoc.

6.  Permission issues: Permissions problems on the filesystem caused committing to the repository to fail. Or the signing process to time out.  Or both.

7. Network timeouts aka no network love.

Image © zoso_tc, http://www.flickr.com/photos/zoso_tc/3024964999/  licensed under Creative Commons by-nc-sa 2.0    

8. Human Error: The usual suspects compile errors, uncoordinated changes across projects, problems in builder itself, corrupted jars etc. have sent many builds to an early death.

9. Upgrades invoke the unexpected.  Changing a ssl certificate unleashed shenanigans.  An simple upgrade of a test machine caused failures.

Image © waferboard, http://www.flickr.com/photos/waferboard/5321533361/  licensed under Creative Commons by-nc-sa 2.0    


10.  Not respecting resource constraints.  Consuming all the disk space, CPU, and bandwidth available is a fine way to finish off a build.

How your builds failed?  Any exciting ways I've missed?

Read more...

Looking toward the Indigo finish line

This week, the Eclipse and Equinox projects released 3.7RC3.  For the past month, we have been in end game mode.  This means that make release candidates available about once a week, each with progressively stringent requirements to release a fix. All code changes require approval as follows

RC1 - Another committer must +1 your bug before you can submit a change.
RC2 - Two committers must +1
RC3 - Two committers and a component lead must approve.
RC4 - Two component leads must +1 your bug. A component lead can veto your change. Steve Northover coined the term intergalactic approval for a bug fix at this stage of the game.

Image © lrargerich, http://www.flickr.com/photos/lrargerich/4999906554/ licensed under Creative Commons by-nc-sa 2.0 

During this entire period, documentation changes can go in without approval.   During RC3 and later, all code changes must be announced to our project's release engineering mailing list to communicate to the other committers that you intend make a change.

There are some interesting parallels between the Eclipse end game and long distance running.  This weekend, 40,000 runners and 100,000 spectators will participate in Otttawa's Race weekend.   The week before their race, athletes participating in the longer distances will taper their runs.  In other words, their training mileage drops significantly so that they're well rested for race day.

Image © Gamma-Ray Productions, http://www.flickr.com/photos/29143375@N05/3574211684/ under Creative Commons by-nc-sa 2.0 


At Eclipse, the process is similar.  We taper our bug fixes as we approach release day. Eclipse is known for it's stable and predictable releases. At lunch yesterday,  my committer colleagues remarked that some of their dependencies (not Eclipse projects) just release at regular intervals and and don't have a ramp down process.  Other projects release occasionally and then don't have a release for several years.  No predictable release schedule.  At Eclipse, we are predictable and stable.  Some may call that boring, but it allows other projects and products who depend us to consume us at regular intervals.  Eclipse 3.7 is especially stable this year given that many committers have been busy releasing innovative new features to Orion and Eclipse 4.1.

We also have weekly test days where the committers and community test the builds and ensure that there aren't any regressions that were recently introduced.  For example, here is the PDE team's test plan. 

In addition to reducing the amount of changes we release to the build,  to ensure the stability of the code base, this tapering of bug fixes and the associated approval process also ensures that other committers have a chance to evaluate our patches.  This sanity check ensures that the fixes are both significant enough to warrant releasing to the build at this time and technically correct.  I can't speak for other committers, but at this stage of the Eclipse release, we are all a bit tired.  So it's good to have several sets of eyes looking at your patch.

Committer after Indigo release

Image © kaibara,http://www.flickr.com/photos/kaibara/4068996309/ licensed under Creative Commons by-nc-sa 2.0 

At this stage of the game, only serious bugs are fixed.  It's not worth causing ripples within the code to fix a minor bug only to find out after the release is available that this fix had intended consequences.

Image © Marc Dezemery, http://www.flickr.com/photos/mdezemery/295687769/ licensed under Creative Commons by-nc-sa 2.0

What process does your project use to ensure that your code base is ready for release?

Further Reading
Eclipse 3.7 Endgame plan

Read more...

SDK code coverage with JaCoCo

Today, I had to pleasure of closing  bug 241254 which has been open for over two years.  It was a request to run a code coverage tool against the SDK during the build.

We used JaCoCo which is an EPL licensed code coverage library brought to you by the same team that created EclEmma.  Why did we chose JaCoCo?

1. Help from JaCoCo committers. At EclipseCon 2010, Marc Hoffman (JaCoCo committer) indicated to Olivier Thomann that he was interested in helping us to implement JaCoCo in our build.  
2. Performance.  Other code coverage tools made the JUnit tests take significantly longer.  Our tests take long enough to finish as it is!  Olivier tested JaCoCo and found that it only took the JDT core tests about 2% longer to complete with JaCoCo enabled. Our 68,000 JUnit tests take about seven hours to run in parallel on three platforms.  The JDT Core tests comprise 37,000 of these tests, thus we estimated the impact of running  JaCoCo during the build would only increase the test run by about eight minutes.
3. Classes are instrumented on the fly and and remain untouched after the code coverage data is generated.  Other code coverage tools require you to instrument the classes for code coverage. Given the huge code base of the SDK, this didn't seem like a feasible alternative.
4.  JaCoCo reports look awesome.

How did we implement JaCoCo in the build?

1. Olivier tested an earlier version of JaCoCo and worked with the JaCoCo committers to address some issues.  Once these issues were resolved, we opened IPZilla bugs to consumed JaCoCo as part of the Indigo release.
2. The Eclipse SDK JUnit tests are run with the assistance of a project called org.eclipse.test.    An Ant script called libary.xml is used to invoke the test suites for each test bundle.  We added the JaCoCo agent and Ant jars to a new library directory of this project.These jars are then added to the extraVMargs property when the tests are run. The libary.xml also specifies the output directory of the coverage data (*.exec files). 
3. When the tests are run, corresponding exec files are created for each test bundle.
4. We modified the test.xml that is used to run all the tests suites to generate a code coverage report upon completion of the JUnit tests. All the *.exec files are merged into a single file.  A coverage report for each bundle in the SDK is run.  (excluding Orbit and doc bundles as well as fragments). The Ant for the report generation looks like this:

One problem that we encountered was that that JaCoCo report task was running out of heap space when the source files were passed to it as as zipfileset instead of a fileset.  This problem occurred especially when attempting to generate source reports for large bundles such as jdt.core. We overcame this problem by unzipping the source bundles into a temporary location and passing the fileset.

In addition to code coverage percentages, the report generates html of the source files that highlights the code coverage within the code itself.  For example:

All this information consumes about 1GB per build.  (Sorry Denis and Matt).  Thus I have only enabled it for our weekly integration builds, and the data will not be sent to the mirrors.

The code coverage reports  for 3.7M6 are now available. Check out your favourite Eclipse SDK bundle!



References
JaCoCo project
JaCoCo mission and design goals
JaCoco Ant tasks
Bug 241254 - run code coverage tool during build
Marc Hoffmans's JaCoCo talk at Eclipse Summit Europe 2010

Read more...

Thoughts on Making Software

My husband (aka Mr. Releng) and I were driving home from his office party in mid-December and had the following conversation.

Me:  A publicist from O'Reilly emailed me today and asked if I would like a free copy of Making Software.

MR:  Huh.  Why did they offer you a free book?

Me:  I don't know. I mentioned to one of my Eclipse colleagues on Twitter  that I thought it would be an interesting book to read.  Also, one of the editors is Greg Wilson, who's also the editor of the upcoming The Architecture of Open Source Applications.  (I contributed a chapter on Eclipse to AOSA).

MR:  Next time, mention on Twitter that you'd like a free car. What's the book about?

MR: Free car from Twitter?  Don't get your hopes up.  The book investigates the evidence that supports common software engineering practices. In medicine, a clinical trial is conducted to see if a new drug has a statistically significant effect compared to placebo or an existing treatment. The same evidence based principles can be applied to software engineering to determine if TDD or Agile methods are actually effective.  I've always thought that there was a lot of shouting but scant evidence to support different software development practices.

MR:  Yeah, undergraduate computer science is engineering.  Graduate level computer science is math.

From xkcd

As you may have guessed, I'm married to a mathematician.

In addition to being a fan of open source, I also enjoy reading about different scientific disciplines.  I love reading scienceblogs and have read many great books over the past year about evidence based medicine. So when I heard that there was a book available that examined what software engineering practices actually work, I was intrigued.

In any case, I finished reading it recently.   It was very interesting and I learned a lot!  The book is split into two sections.  The first section dealt with different research methods.  For instance,

• How to conduct a systematic literature review
• Empirical methods that can be applied to software engineering studies and why software engineering is inherently difficult to measure quantatively.
• How to decide on the papers to include in a meta-study. 

From xkcd

 
The second half of the book examines the evidence for different questions in software engineering.  For instance:

• How do you measure programmer productivity?  Are some developers really an order of magnitude more productive than their team mates?
• Does test driven development result in better software?
• What's the cost of discovering a bug early in the development cycle versus after the product has shipped?
• What working environment (cubicles/offices/open concept etc) are the most productive for software developers?
• Is there a measurable difference in software quality between open and closed source software?
• What are the reasons for the low proportion of women working in the software industry?
• Does the use of design patterns improve software quality?
• How do mine data from open source repositories for your own studies (Chapter 27 uses the Eclipse project as an example :-)

All in all, I found it a very interesting book that examined the actual empirical evidence to support or refute some of the sacred cows in software engineering. I think this this is a refreshing step forward for our profession.  If there aren't numbers to support that the way we work is effective, shouldn't we alter our path to use better methods?

Further reading
Software Carpentry: Empirical results

As an aside, some great books on evidence based medicine are
Bad Science by Ben Goldacre
Trick or Treatment by Simon Singh and Edzard Ernst
Snake Oil Science by R. Barker Bausell

Read more...

Eclipsing the build

A plan item for 3.7 is to transition the Eclipse and Equinox build process to run on eclipse.org hardware.  Why may you ask, isn't this the case today? Two reasons:

1.  Until recently, the Eclipse foundation didn't have hardware to support our requirements of running tests on multiple platforms (Windows, Mac, Linux).
2.  There wasn't a plan item to transition our build to eclipse.org until 3.7.   You may think that we open source developers are happy hippies who have the freedom to work on the bugs that interest them :-). The reality is that I prioritize my bugs as follows:

• Fix bugs that cause the build to fail.
• Fix bugs that block other committers from moving forward with their work or are necessary for legal reasons.  
• Plan items
• Everything else

I was going to write a post describing the progress migrating to eclipse.org hardware but I thought it would be a good idea to give you some background regarding how the Eclipse and Equinox project's build works today. 

The Eclipse build creates SDKs for 15 platforms.

A graphical representation of the 15 platforms we build  (os,ws,arch)

We use fragments to define platform specific code that is associated with a host bundle.  In some of these fragments, there's C code that needs to be compiled on the platform specific hardware to create binary libraries.  For instance, the SWT and equinox launcher fragments are examples of  these artifacts. We have about seven machines to compile the libraries for these 15 platforms, as some are cross compiled.  The SWT and Equinox team have hudson instances, which connect to all these internal IBM servers, compile the C code, and commit the resulting libraries in binary form to CVS at eclipse.org. This part of the build isn't transitioning to eclipse.org.

A simplified description of the existing Eclipse build that produces the artifacts that are available for download on eclipse.org is shown below.   Essentially, once a build is launched from cron, the build scripts check out all the code from eclipse.org to the IBM build machine which compiles the bundles. These bundles are copied to eclipse.org to be signed, then copied back to the IBM build machine to be assembled into a p2 repo, from which we create SDKs to run the tests. The zips, repos and test results are rsynced to eclipse.org.

Once we get the issues worked out with the new Hudson slaves to run tests, all the JUnit tests will run on eclipse.org hardware.  Eventually,  we hope to run the performance tests there once we have sufficient hardware.

Advantages of moving the build to hudson.eclipse.org

1. The build process will be more open and other Eclipse and Equinox committers will be able to start a build.  Today, I manage the crontab of the build machine.
2. Fewer issues with network timeouts due to the fact that the eclipse.org filesystem is local to Hudson.
3. Hudson has a rich feature set and many plugins to extend it. 

Disadvantages

1. Like kindergarten, we'll have to share the filesystem and machines with others.  Today the build runs on dedicated machines and thus we don't have resource constraint issues from other teams.  (The build process itself isn't faster at eclipse.org because of these resource constraints, but the tests are because at the moment we are the only team using the Windows and Mac test machines.)
2. Can't hack and slash the build on the the command line to rerun a single test suite or restart the build manually.

In a future post, I'll describe the process to transition our builds to run on eclipse.org and the obstacles that we have overcome.

How can you help?  Consider donating to Friends of Eclipse. 

References

Build at Eclipse.org

Graphics thanks to open source clip art

Servers
Database
iMac
Server cabinet
Tower
Database

Read more...

Implementing shared licenses with 3.7M5

This is the best Eclipse license I've ever seen.

Image © chriscardinal, http://www.flickr.com/photos/disatasu/3243844762/ licensed under Creative Commons by-nc-sa 2.0

Conversely, dealing with license files in Eclipse features is a bit painful.  Today, each time the Eclipse license changes, you need to copy the new license files to your features.  The license files included in the Eclipse SDK are highlighted below:

These same files are included in the 46 features that the Eclipse and RT Equinox project builds.  This is very tedious to update when the license files change. Lots of copy and paste. The license text also appears in the feature.properties.


In Eclipse 3.7M4,  the PDE and p2 teams added support for shared licenses.

The license files will be copied from the license feature to the feature that refers to it.  In 3.7M5, I modified our features to use this shared licenses. For instance, the beginning of the feature.xml for the Eclipse SDK now looks like this:

To implement this, I followed these steps. 

1. Create a license feature. This feature doesn't include any bundles or features. It only stores the license files which its build.properties reference.   The feature.properties has only two properties - the licenseURL and license. 

2. Update the existing features to reference the license feature.  Remove the license files from these features.  Remove the references to the license files from your feature's build.properties.  The values will be inherited from the build.properties of the license feature.  Remove the name and values of licenseURL and license from the feature.properties. These will be included from the license feature. Ensure that you don't have duplicate properties in the feature.properties of the license feature and feature your are updating. This will cause a build failure.


3.  Update your map files to include to the new feature. You don't need to nest the feature in another feature to fetch it, this happens automatically. For example, this is where our license feature is located

feature@org.eclipse.license=v20110121,:pserver:anonymous@dev.eclipse.org:/cvsroot/eclipse,,org.eclipse.sdk-feature/features/org.eclipse.license

4. Run a test build. Fix typos until you have a clean build. Verify that all your features still include the appropriate license files. 

There isn't an IU for the license feature included in the p2 repository.  The license text is included in the metadata.

Note that you'll need to build with 3.7M5 bundles.  There was a bug in the 3.7M4 bundles that prevented shared licenses from working in generated source features.

The advantage of this approach is that when the license files are updated, we'll only need to update the license feature.  We'll also have to increment the versions of the license feature in the referring feature, but that's a simple search and replace. 

Some other implementation details: I could have also stored the copyright information in the feature.properties of the license feature. However, the copyrights of our features are not identical, so I didn't choose this approach. This may be useful for other teams.

Thanks to the  PDE and p2 team for implementing this!


Further references

Bug 306818 - Improve license support in p2.
License mechanism description in wiki
Bug 332662 - Adopt new feature that allows to share the license file

Read more...

Revert to an earlier p2 profile from the command line

Today, we're running builds toward 3.7M5 for the milestone that will be available Friday, January 28.  This morning I updated to our latest integration build from the repository. Unfortunately, one of the bundles had a compile error which was serious enough to cause Eclipse to crash on startup.

If you want to revert your installation to a previous version, this is easy to do from the UI. Chris describes this here. 

However, if you can't access the Eclipse UI, reverting becomes a bit more complicated. The online help illustrates how to use the p2 director application to revert your install to a previous profile state.

The list of profiles available in your Eclipse install are located in your profile registry.  The highlighted profile id below reflects my working installation from last week.

To revert to this profile, I downloaded a new build, extracted it to a directory and ran the following command

C:\N20110122-2000\eclipse\eclipsec.exe -application org.eclipse.equinox.p2.director -repository http://download.eclipse.org/eclipse/updates/3.7-I-builds -revert 1295719004390 -destination c:\I20100309-0809\eclipse -profile SDKProfile -bundlepool C:\I20100309-0809 -p2.os win32 -p2.ws win32 -p2.arch x86

Operation completed in 68759 ms. 

My install was reverted to the previous profile and I could once again start Eclipse.

Read more...

Hudson best practices and Eclipse

One of the plan items for Eclipse 3.7  I've assigned is to migrate the Eclipse and Equinox build to run on the Hudson installation at eclipse.org.  So I've spent a lot of quality time with Hudson lately. (Soon to be called Jenkins).

Today, I attended a webinar about optimizing Hudson in production hosted by Kohsuke Kawaguchi of CloudBees. Since my handwriting is similar to the last slide in this Oatmeal cartoon, I thought it would be better to jot my notes down in a blog post. As I was listening to his suggestions, I thought about how his seven best practices apply to our use of Hudson at Eclipse.


1. Backups 

• Backup your Hudson install to protect from disaster and accidental configuration changes.

 

Image © davemorris, http://www.flickr.com/photos/davemorris/2395980976/sizes/z/in/photostream/   licensed under Creative Commons by-nc-sa 2.0 

• $HUDSON_HOME on the master stores everything that needs to be backed up. The slaves doesn't need to be backed up.
• Live backups are fine as configuration changes are atomic
• In addition to the backup of the configuration, a backup of the filesystem is necessary to provide consistent snapshot.
• Backups are great but can you restore?  On a regular basis, try restoring your hudson configuration and starting up a test hudson instance with the restored hudson.war file.

2. Disk

• Prepare for disk utilization growth
• Space is more important than speed when ordering new drives
• Plan for expandable disk volumes
• If it's too late, symlink is your friend

3.  Use native packages

• For instance, *.deb, *.rpm.  Easy to update and install, and they include init scripts.
• Configuration is stored in /etc/default/hudson and /etc/sysconfig/hudson
• Existing $HUDSON_HOME can be migrated
• Native Windows package is a work in progress

@Eclipse:  Backups and disk configuration are managed by the webmasters, along with upgrading and installing hudson.


4. Distributed builds

• You will grow beyond a single system
• Increasing load on a single machine is not the only issue
• It's cheaper to grow horizontally (additional machines) versus vertically (more memory and CPUs on a single machine)
• It's also good to have isolation between build processes in case you want to diversify the test and build platforms
• Let master launch slaves via SSH or DCOM. This makes it easier to keep the cluster up and running.
• SSH public key authentication makes it easy to connect to slaves on disparate platforms.

@Eclipse: Yes, we have distributed builds and several platforms available for test purposes.

5.  Labels

Treat build machines like livestock, not like pets

Image © davegroth, http://www.flickr.com/photos/davegroth/9107888/sizes/m/in/photostream/   licensed under Creative Commons by-nc-sa 2.0 

• Build machines should be interchangeable
• Don't tie builds to a specific build machine,  unless there are platform limitations. This approach will yield better resource utilization and less downtime.  Queued builds can use the next available machine instead of waiting for a specific machine.
• When using labels for your Hudson slaves, name them to reflect their capability.  For instance, if the slave is Mac or Windows hardware, the label should reflect this.
• If  there is a real reason to limit build to run on a single machine (such as wanting to run platform specific tests), tou can use boolean expressions with labels.  For instance, this Hudson job shouldn't run the slaves running Mac or Windows

@Eclipse: We use label our build machines as livestock.  No pets for us. However, I'm quite envious that the Mozilla foundation has adopted red pandas (firefoxes).

  6.  Invest in a good URL

• By default Hudson runs on port 8080.  This is difficult for users to remember.
• Use the host's alias instead of the machine name.  Thus if the machine names changes, the users won't have to go to a new URL.
• Share port 80 with other applications using Apache reverse proxy with which will also allow you to run Hudson as a non-root user.   

@Eclipse: https://hudson.eclipse.org is short and simple.

7.  Try to keep the build records under control.

• Discard old build records if you can
• Removing old builds reduces start-up time and memory usage. 
• Settings are on a per-project basis. For instance, here are settings for one of my Eclipse builds.

@Eclipse: Yes, we do clean up old builds. Also, the webmasters have created a cron job to send a friendly email every week listing of the Hudson disk utilization to remind the release engineers to clean house.

The slides are available here and obviously provide a lot more detail than my short summary.  If you're interested the best practices for configuring Hudson for a production environment that has room to grow, this presentation is provides very useful suggestions.

Read more...

Smashing open source stereotypes

The Wall Street Journal published an article yesterday where it described the open-source software movement, whose activists tend to be fringe academics and ponytailed computer geeks. This is one of the many unfortunate stereotypes surrounding open source that I've heard over the years.   Let's break some of those down.


1.  Open source is a fringe movement.

Open source builds mainstream software. I work all day long contributing to open source software, as do many of my colleagues.  Why do corporations pay us to contribute to software that doesn't have a price tag?  It's in their self-interest to have employees improving the open source software that underlies their commercial offerings.  Here are some of the fringe groups involved in Eclipse.

Source: Eclipse Foundation Members' Meeting  Q4 Update December 16, 2010

These unknown companies are members of the Linux foundation.

2.  Open source is not professional.

At Eclipse, we ship our software on time every year.  We've done that for seven years.  That's professional.

 Source: Ian Skerrett: The Helios Train has arrived

3.  Open source contributors are loners sitting in their parents' basement working on arcane bugs.

Nope.  Open source is very social.  We interact on IRC and twitter.  We attend democamps, learn about new projects and build new businesses. We speak at conferences. The software we work on makes a difference in the world. It helps monitor robots on Mars, manages trains in Switzerland and models chemical reactions.

Source: Madhu Samuel: Eclipse Democamp Bangalore 2010

4.  Open source developers aren't in good physical condition and don't have interests outside of work

Again, a stereotype that has been proven wrong.    We ran 570K at EclipseCon 2010. 

Open source contributors run marathons, bike, curl, swim and play soccer or  hockey.  In fact, you can order an Eclipse bike shirt.

We also volunteer at schools and raise money for charity. 

5.  Open source contributors are always male.

Source: Miriam Ruiz: Women in Free Software

Wrong again. 

We may be a small minority, but here's hoping that these fine female role models will inspire a younger generation of women to consider the amazing career opportunities that open source has to offer.  Two generations ago, female doctors were rare.    Today, women are over 50% of new Canadian medical school graduates. So, may borrow a phrase from a recent campaign, it will get better.

What other open source stereotypes would you like to smash?

Read more...

Thoughts on Being Geek

Sitting on the plane travelling to Nova Scotia for the holidays, I read Being Geek: The Software Developer's Career Handbook by Michael Lopp. I've wanted to read this for a while so I was happy to finally have some time to do so.

It was a very informative and funny book, especially for someone like me who has spent a long time working in the software and IT services industry. Some key points it covered:

• You are responsible for your career. Don't depend on your manager or HR. They are looking out for their own interests.
• The importance of mentoring and having a career plan.
• How to negotiate your salary and benefits for a new job, and how this calculation should be altered if you are looking to move to a start-up versus an established company.
• Evaluating organizational culture outside the boundaries of hierarchy.  Where is the informal power  within an organization?
•  I really liked the chapter entitled "Your People" on the art of networking and the importance of connecting with people in your community face-to-face and getting to know them better.  As I read this I thought, my people are the Eclipse family. 
• Strategies for dealing with different types of managers and co-workers.
• How to decide if you want to be a manager.
• Dealing with a crisis situation such a major bug just before the ship date.
• The downsides of working in our industry.

As an Eclipse committer, this quotation from the chapter on selecting the tools to use as a developer made me laugh.

"Yeah, I know all about the glory of integrated debugging, and I see all you Eclipse guys having a ball, but what I have found in many years of developing is that embracing fancy tools means tinkering with tools to get them to behave how you want."

-Michael Lopp, Being Geek

There's something to be said for simplicity.

My only criticism about this book is that the example software developers in the book were overwhelmingly male.  There were very few female software developers if any used to as characters in his stories. Legend has it that they do exist.  All the examples of women in the book seemed to be in product marketing or similar roles.

Anyways, if you are interested in a thought provoking book about strategies for managing your software career this is definitely a good one.

Read more...