• Skip to primary navigation
  • Skip to main content
  • Skip to primary sidebar

An Antic Disposition

  • Home
  • About
  • Archives
  • Writings
  • Links
You are here: Home / Archives for Rob

Rob

Accounting for Vendor Lock-in

2012/07/12 By Rob 3 Comments

The Trojan Nuclear Plant on the Banks of the Columbia River Portland General Electric, the Builder of the Plant, Has Encountered Great Opposition From Environmentalists 05/1973

I am not an accountant.   However, as a Graham and Dodd value investor over the years, I’ve picked up some of the fundamental principles.   A key one is the Matching Principle, that revenues and expenses should be booked in a way that clarifies the underlying business performance, rather than based purely on the timing of cash transactions.  In some cases this requires the use of special accounts, for things like depreciation, where the lifetime of a fixed asset (say factory machinery) extends beyond a single revenue cycle.

A similar technique is used when dealing with deferred expenses. For example take the case of a nuclear power plant.  A plant has a useful lifetime, but when that end date arrives there is a clean up cost.   The property is not immediately usable for other purposes, but must undergo an expensive remediation.  From an accounting perspective there is an asset retirement obligation, a form of deferred expense.  This deferred expense is recognized on the books as a liability based on the present value of the expected clean up cost, which is then depreciated.

I think of vendor lock-in in a similar way, but one where the clean up costs are commonly not recognized, either formally or even informally, as a deferred expense.  Instead, the costs are attributed 100% to any alternative vendor.  This leads to absurdities like the claim that moving to OpenOffice from Microsoft Office would be a huge expense.  That is like saying that an old, non-functioning power plant cannot be used for any other purpose because the cleanup costs are too high.    The costs could be real, but we only obscure the economic reality when we recognize vendor lock-in only at exit.  It should have been considered at the entrance, and as a liability against picking a closed solution.

Something to consider.  When you pick:

  • A closed solution
  • A non-open standard

In those cases you are risking vendor lock-in.  And by doing so you are committing  your company to either a perpetuity of lock-in, or to a future expensive remediation to restore  your options to the point where you can make alternative choices.  The smart way of doing this is to consider, in terms of analysis to aid decision making,  the cost of lock-in up-front, as a deferred expense, a liability.  When this is done you can more accurately make comparisons among available solutions, closed and open, knowing that you are fairly accounting for the true economic costs of each choice.

  • Tweet

Filed Under: Economics, FUD, Open Source

Perspectives on Apache OpenOffice 3.4 download numbers

2012/06/22 By Rob 1 Comment

You may have read, on the Apache OpenOffice blog, news that the project has had 5 million downloads in the first 6 weeks since the release of version 3.4.  And as the above chart shows, the download rate has increased in the past two weeks, as we’ve started to roll out the upgrade notifications to OpenOffice.org 3.3 users.

When I mention the “5 million” achievement, the reaction is generally along the lines of, “That’s excellent !!!  Right?  That is good, isn’t it?”  The fact is the number is large, but without comparison or context, it is hard to gauge.     I think I can provide some comparisons and context to put these numbers in perspective.

First, let’s look at OpenOffice.org 3, and their famous claim of 100 million downloads.  That was in the time period from October 13, 2008 to October 28, 2009, so 380 days.  That averages out to around 260K downloads/day.   I’m not quite sure what they counted as a “download”, whether just full installers, or language packs as well.   And that time period overlaps with several releases (3.0.0, 3.0.1, 3.1.0 and 3.1.1, so there is some double, triple and quadruple counting of users due to upgrades.

For another comparison, let’s take a look at LibreOffice.  They claimed 7.5 million downloads between January 2011 and October 2011.  That averages out to 27K downloads/day.    And again, it is not clear if that counts all downloads, including multiple downloads by the same user as they update from release to release.

So how does Apache OpenOffice 3.4 compare?  Let’s state the numbers as conservatively as we can.  We’ll count only installer downloads, not language packs or SDK’s.  And we’re counting only for a single release, AOO 3.4, so there is no double counting due to upgrades.  Based on these assumptions, our average download rate has been 118K downloads/day.  (But as the chart shows, since we enabled the update notifications, the rate is now more like 170K downloads/day.

So overall I think we’re doing quite well.   There is room for improvement, but it is a good baseline against which we can show progress.  One thing we can do to grow these numbers to increase the native language support, to restore some of the key translations.   If you are interested in volunteering with Apache OpenOffice, you should read this page, and then send an email to our mailing list to introduce yourself and your interest.

A quick side note:  Some readers will observe that Linux users get their software from the distros, not from downloading from a website.  This is a safe assumption for most, but not all Linux users.  But that doesn’t really change the math much.  Assume that none of the LibreOffice downloads are from Linux users.  Assume that the entire 27K/day are entirely Windows and Mac users.   Then, we can do an apples-to-apples comparison to the Apache OpenOffice numbers, where we know that only 3% of the downloads are from Linux users.  So the better comparison would then be to compare  a very conservative 0.97 * 118K = 114 K/day versus LO’s best-case 27K/day for Windows and Mac.    A similar calculation could be done on the legacy OOo 3 figure, with similar results.

  • Tweet

Filed Under: Apache, OpenOffice

+1 for Apache OpenOffice 3.4

2012/05/08 By Rob 3 Comments

Read more in the official announcement.  You can download Apache OpenOffice 3.4 now, from http://download.openoffice.org/    Tell your friends.  And welcome home.

  • Tweet

Filed Under: Apache, OpenOffice

Gorilla Free Software Marketing, Chapter 8: Community Metrics

2012/04/01 By Rob 3 Comments

The Importance of Metrics

Revolutionary movements require revolutionary progress.  However, at the start of a Movement, such progress may not be immediately evident to those whose views of progress have been tainted by commercial software, where progress is measured by feature enhancements, quality improvements and user satisfaction.  These are false idols and the shallow view of progress they support are irrelevant for true free software.

Rejecting the repressive capitalist view of progress-as-production and production-as-consumption, and the doctrinaire emphasis on results-oriented metrics, we instead adopt the dialectic of progress-as-being and being-as-becoming, with metrics illustrating not what is produced, but what is willed.  Rather than galley slaves, prodded by whip lashes to “row harder!”, our motto  shall be: “row louder!”

As Mark Twain famously wrote,  “There are three kinds of lies: lies, damned lies, and statistics.”   Our aim in developing metrics is to avoid the taint of this condemnation by avoiding the statistical sciences entirely.

Two metrics that any free software marketeer must be able to produce are:

  • A measure of the size of the community, in order to demonstrate the overwhelming strength and vigorous growth of our Movement.
  • A measure of the diversity of the community, in order to demonstrate that it is a true People’s Movement with a broad base of support.

Community Size

A metric that can never disappoint is  “cumulative number of developers” on the project.  Calculating this metric is simple:  count the total number of individuals who have contributed to the project since it started.  You are not concerned with the number of contributions, the quality of contributions, whether the person did one patch and then was never seen again, or any other extraneous detail. You’re just counting names.  Any project can use this metric to show month-after-month steady improvements.

The genius of this metric is that it can never decrease. It is mathematically impossible!  Once a name is added to your list, it is never removed.  One a contributor, always a contributor, at least on paper.  Worst case, even if an asteroid should hit your next project conference and kill every one of your developers, you could still report that your numbers were flat.  Unfortunately, your developers would be as well.

Advanced marketeers should also note the following additional techniques, which can be used to generate even more impressive numbers without additional effort:

  • Don’t just count those who are writing code.   Almost anyone can be called a “developer” these days.  Translators (“Localization Engineers”), build lab guys (“Configuration Management Engineers”), testers (Software Quality Engineers),  etc.  Include all of their contributions.
  • Don’t limit yourself to those who actively contributed code to your project.  You can also include developers who contributed to precursor versions of your code, or who contributed to 3rd party modules. They might not even know that their code is in your product, but that doesn’t matter.  We appreciate their “contribution”  nonetheless and should acknowledge them as an integral part of our thriving community, in spirit at least.
  • One you have made the novel step of  counting non-project members as developers, there is nothing in principle against extending this even further to the developers of the tool set and libraries you are using.   Credit them all, living, dead and legendary.  Larry Wall, Dennis Ritchie,  Alan Turing, and St. Hubertus, patron saint of mathematicians, can all be listed as developers on your project.
  • With some advance planning your project’s development team can help increase these numbers even more.  Have them think of some simple text manipulation tasks that can be done by volunteers with little knowledge or understanding of the code.  For example, have them do things like reformat code,  spell check comments, alphabetize include directives, ensure that every C/C++ file ends with a newline character, etc.  Although this will not improve the product for your users, it will enable a much larger group of contributors to get involved so we can add their name to our list.  And once on the list, it stays on the list forever.  I am told on reliable authority that such code changes are perfectly safe and cannot have a negative impact on product quality.

But be warned: use of these advanced techniques might open you up to criticism of promoting numbers that are meaningless, that they saying nothing about the actual size or composition of your development community.   Such criticism can easily be dismissed by feigning to be insulted and responding along the lines, “How could you possibly suggest that we not recognize the hard-working {translators | build lab guys | testers | dead mathematicians |  patron saints} who {contributed to|had stuff we took without their knowledge for} our project?”.   This argument will almost win, since no one will want to appear ungenerous, especially when intercessory saints are involved.

Community Diversity

Another metric that you might be asked for is a metric to illustrate how much of the project is dependent on any one company, such as the project’s main sponsor.    A common error is to look at the contributions made to the project and report how much was apportioned to which individuals and companies, based on recognized software metrics, like # of commits, lines of code, function points, etc.  You must not fall into that trap!

A much better metric, if you want to be seen as diverse, is to count the number of developers in each company. Do this without regard to whether the person made a one line change 2 years ago and was never heard of again, or whether the person works 14 hours a day on the project every day. Just look at the number of developers.   If you have already followed the advice outlined above, and increased your “cumulative number of developers” metric, then you are perfectly positioned to also demonstrate your diversity.

For example, suppose you have 400 developers, and 10 of them do 90% of the work, and they are employed by a single company.  Avoid the naive mistake of saying that one company was responsible for 90% of the contributions.  Instead say that the company’s developers (note we’re emphasizing people not work) represent 10/400 or only 4% of the project.   That is the genius of this metric.  You can have almost all the work done by a single company and still claim that your community is diverse.

  • Tweet

Filed Under: Humor, Open Source

Ending the Symphony Fork

2012/02/01 By Rob

What is a fork?

A fork is a form of software reuse.  I like your software module.  It meets some or many of my needs, but I need some additional features.

When I want to reuse existing functionality from another software product, I generally have four choices:

  1. If your module is nicely designed and extensible, then I might be able to simply use your code as-is and write new code to extend it.
  2. I can convince you to modify your module so it meets my needs.
  3. I can work with you in your open source project to make the module (“our” module in this case) meet our mutual needs.
  4. I can copy the source code of your module and change the code in my copy, and integrate that modified module into my product.

Note that options #1 and #2 are the only options available with most proprietary modules, since these techniques don’t require access to the module’s source code.  Options #3 and #4 are the additional options made possible by open source.  Option #4 is what we mean by “forking” .  Forking is enabled by open source software and is fundamental to open source ecosystems.  It is neither good nor bad.  It is a tool, part social, part technological, for overcoming an inability or unwillingness to collaborate.  The problem is not with forking.  The problem is the conditions that lead to forking.

Why do forks come about and how do they end?

Forks can come about for many reasons, including leadership conflicts, ideological differences and other political issues, as well as differences in vision and technical direction of the project.

Generally, a fork ends when the conditions that necessitated the formation of the fork have been resolved.  At least that is true for rational participants who are merely trying to optimize outcomes.  But intransigent ideological forks can continue indefinitely, and often do.

The technical side of ending a fork is typically a code merge, as different branches of the project are brought back together again.  This can be laborious, but it is a one-time task.

Ending the Symphony Fork

With the move of OpenOffice to Apache, this open source project has made the critical move from a corporate-led open source project under asymmetrical licensing terms, to a community-led open source project under a single permissive license.  This is a tremendous change and one that should lead all forks of OpenOffice,  and all those who wanted to get involved with OpenOffice before but never did,  to reexamine their orientation to the project.

John Maynard Keynes, when criticized for reversing his position in a dispute, famously quipped, “When the facts change, I change my opinion. What do you do, sir?”  The “facts” of OpenOffice have changed, with the move to Apache, and this change of venue has made a huge impact on the Symphony team, which recently announced that it was ending its fork and committing to contribute their code to Apache and to work with that community going forward.

This does not mean that Symphony enhancements are going away.  Far from it.   We’re very proud of the UI work and other innovations in performance, accessibility and interoperability we’ve brought to Symphony and we will be offering the source code of these enhancements to Apache, and if accepted, will work within that project to merge these changes into Apache OpenOffice.  The DNA of Symphony is not going away.  What is going away is Symphony as a fork, as a divided effort.  The Symphony DNA, the cool work the Symphony team has worked so hard on, will live on, in Apache OpenOffice, combined with other ongoing contributions from the community, in a larger, stronger development effort.

Now that the Symphony fork is ending, the obvious question is:    Who will be next?    If we can end a four-year old fork and merge in our work with Apache, then so much easier it should be for forks that have been around for far less time.  “When the facts change, I change my opinion.  What do you do, sir?”

If you are interested in learning more about the Apache OpenOffice project, I recommend browsing the project’s website and blog.  If you want to get involved, you can sign up for the ooo-dev mailing list and post a note to introduce yourself.  As we push closer to our 3.4 release candidate we’re in particular need of volunteers to help us test this release, on Windows, Mac or Linux.  If you are interested in helping with that, be sure to say so in your note.

(This post has also been translated into Serb-Croatian by Anja Skrba.)

  • Tweet

Filed Under: Apache, Open Source, OpenOffice

  • « Go to Previous Page
  • Go to page 1
  • Interim pages omitted …
  • Go to page 5
  • Go to page 6
  • Go to page 7
  • Go to page 8
  • Go to page 9
  • Interim pages omitted …
  • Go to page 69
  • Go to Next Page »

Primary Sidebar

Copyright © 2006-2023 Rob Weir · Site Policies

 

Loading Comments...