Before I get started with this post, I wanted to let people know that I am working with representatives of other companies to form an Enterprise Working Group for Firefox. The goal of this group will be to work together to document enterprise requirements and either create extensions or submit patches to Firefox to meet these requirements. We hope that anyone interested in Firefox in the enterprise will join us. We'll be having our first meeting in the next few weeks.

In my previous post I talked about obstacles to the enterprise adoption of Firefox, but it wouldn't be fair to talk about obstacles without talking about the benefits. We all know the benefits to Firefox users, like tabbed browsing and pop up blocking, so this post is going to focus on enterprise specific benefits. Obviously there are many more benefits beyond what I'm covering here. I'd love to hear your opinion in the comments on this post.

Extensions

Extensions are a great way to add genuine business value to Firefox. Within IBM, for example, we have extensions like Koala that can be used to automate business processes, or extensions like Tommy! which take our corporate directory to the next level by integrating other services like blogs. We have an extension available that uses the Firefox password manger to enable single sign on to IBM domains. And of course we have the CCK to produce IBM customized versions of Firefox. We have also seen Greasemonkey used to add business value. For instance, one of our support teams uses a Greasemonkey script to prefill fields in a web application that would normally have to be done with every problem report. The result can be seen in real time savings for support calls.

And these are just few. I haven't even mentioned some of the other extensions that add IBM specific toolbars or enhance our ability to search our corporate directory. So what does this mean for your business? There are probably areas where a simple Firefox extension or Greasemonkey script could greatly enhance the experience of your employees. It's definitely something to keep in mind.

Customization

I really can't say enough about the customizablity of Firefox. Because most of the user interface code is written in JavaScript and can be modified via extensions, I have been able to do some extensive customization. I've had schools approach me about things ranging from removing history or bookmarks to disabling access to preferences. I have been able to accomplish all of this through the use of extensions. If you have specific needs around browser customization, whether it be locking down the browser, or perhaps a kiosk, Firefox can be customized to meet that need.

Web Development

My experience has shown that Firefox has become the web development platform, even for organizations that use Internet Explorer internally. The extensions available for Firefox, like the Venkman JavaScript Debugger, the DOM Inspector, Firebug, and the Web Developer extension make web development much easier on Firefox. And there are even more extensions to benefit the web developer.

Open Source

There are some Firefox benefits specifically because it is open source. You can replace the existing update infrastructure with your own so updates are served from your servers. If you have questions, you can access developers directly. When you open a bug, you can keep up with the status and even choose to fix it yourself. You have access to the source code for debugging problems. You can build your own browser with patches that you want if it comes to that.

Open Standards

By using Firefox, you are encouraging the use of open standards and protocols, and helping to keep the web open.

Summary

That's all I have for now. I know I've only scratched the surface here. Please comment as to additional enterprise benefits. And stay tuned for more info on the Enterprise Working Group.

I've been thinking a lot about Firefox in the enterprise and I wanted to capture some of my thoughts. This two part article will first cover obstacles to enterprise adoption of Firefox (with some possible solutions) and then cover specific benefits to Firefox in the enterprise.

Before I get any complaints, I am aware that there are large enterprises that are already using Firefox (including IBM). I believe that most of these are supporting Firefox as a secondary browser as opposed to switching to Firefox as the primary browser. Also, I'd love to open up more discussion on this subject, so please comment and correct me if I'm wrong.

Introduction

As Firefox gains marketshare, there comes a point where increasing that marketshare depends on the adoption of Firefox in large enterprises. This article investigates what type of issues arise when supporting Firefox in a large enterprise, and what can be done to solve those issues.

The primary areas I will address are:

• Release Lifecycle
• Service and Support
• Business Value
• Third Party Applications
• Intranet Applications
• Deployment issues

Release Lifecycle

Simply put, the current Firefox policy of supporting prior versions of Firefox for six months after the next release is just too short, especially considering the time of year when new versions of Firefox are typically released. Many companies only deploy new software once or twice a year, and the process to get that software deployed takes many months.

I know of a company that deploys software once a year, in September. In order to be a part of that deployment, you have to start piloting your application in June. If this company wanted to move from Firefox 1.5 to Firefox 2, they would have had to pilot it in June, for deployment in September. This means that they would have had an unsupported browser for over five months.

In addition, Firefox so far has been released in the fourth quarter (Firefox 1 was release in November, Firefox 2 was released in October). If you work in IT, you know that new software does not get deployed in November, December, or even January. So three months of the six month Firefox support cycle was simply a wash.

Either Mozilla Corporation needs to step up and extend the lifecycle of Firefox to one year, or some enterprising company should take this opportunity to provide better release lifecycle for Firefox.

Service and Support

When a piece of software is an integral part of a company's business, it is imperative that they have someone to call when they have problems. "Open a bug in bugzilla" or "we accept patches" are simply not good answers when companies are experiencing problems. Certainly companies can staff developers that can build and deploy custom versions of Firefox, but this is the exception, not the rule. In addition, companies that have their own internal help desk need training on how to support Firefox.

This problem is more difficult to solve. Mozilla's role is not to provide one on one support for customers. This is, however, an excellent opportunity for someone to step in and provide enterprise level phone support for Firefox, as well as to create education modules to train internal help desks.

Business Value

Every organization is in business to provide value to their customers. For a publicly traded company, it's about shareholder value. For a nonprofit, it might be about reducing overhead so that more donations can go to their primary cause. Unfortunately, it is difficult to show that supporting two browsers or switching to a completely different browser adds business value.

While I don't have a good solution to this problem, it is worth noting that, for many companies, the move to support Internet Explorer 7 will be just as much work as supporting Firefox. From that perspective, the best way to increase business value
would be to move towards an internal infrastructure that uses open standards so that dependencies on particular platforms are diminished. In addition, if a company ever wanted to move to a platform where Internet Explorer was not available, using open standards would make it easer to move.

Third Party Applications

When most of us surf the web, we don't tend to find a lot of web pages that simply don't work in Firefox. This problem has mostly been solved. Companies, however, use third party applications that may or may not work in Firefox. While the current version of a lot of these applications may work with Firefox, older versions of these applications are deployed in many companies with no plans to upgrade in the foreseeable future due to cost (see Business Value above).

There are a few ways to solve this problem. First off, third party application providers should provide free or low cost upgrades to companies that have software that doesn't work with Firefox. Secondly, when purchasing third party applications, companies should ensure that the software they are purchasing uses open standards. Finally, application vendors should ensure they are using open standards to create their applications so they don't lock their customers into a particular browser vendor.

Intranet Applications

Third party applications aren't the only place where support for Firefox can be a problem. What tends to happen in companies is that internal applications get written, deployed, and then forgotten about. In addition, because it might take years to write an internal application, by the time it is deployed, it might be designed for an older browser. Fixing these applications can be some of the most difficult problems to solve, due to lack of funding and even lack of interest by the developers.

Your company should have policies in place to ensure that internal applications are written using open standards so that they don't depend on a particular browser. In addition, when applications are created, it is imperative that funding be set aside so that if problems are encountered with a particular application in the future, that there is a way to get the problem fixed.

Deployment issues

One of the main things I've tried to do in my job is help with deployment issues. In addition to working on the CCK, I've worked with some smaller entities to deploy Firefox using things like the Firefox Release Repackager. But these things simply aren't enough. Companies already have existing deployment infrastructures using Tivoli or Microsoft Active Directory. In addition, the types of customizations that a lot of entities want to do are outside the scope of the CCK.

While there are third party solutions that provide a customized Firefox to use Active Directory and Microsoft installers, there needs to be more work in the community to make Active Directory support and Microsoft installers an integral part of Firefox. While Firefox developers do not want to make MSI the primary ship vehicle for Firefox, work could be done to make the MSI installer on par with the Nullsoft Installer. In addition, there needs to be more of an ecosystem around customizing Firefox for certain types of deployment.

Closing Comments

So there you have it. Some quick thoughts on enterprise deployment. In the next installment, I'll talk about the benefits of Firefox in the enterprise, and in particular some things we've found out inside IBM. As always, I'd love to here your thoughts, and if I've missed anything.

I have made an alpha of Operator 0.8 available. Special thanks to Elias Torres for the RDFa support.

My primary goal with Operator 0.8a was to attempt to finalize APIs for both Operator and Firefox 3. What I actually ended up with is very similar to the APIs I created with the very first version of Operator. You can see the microformats API for Firefox 3 here (looking for feedback). I'll be documenting the action and microformats API more completely in the next few days.

New features in this release include:

• RDFa support (view only - there are no actions yet)
• Unified actions architecture - actions are no longer specific to a microformat
• Support for Address microformat to allow some actions (like map lookups) to be more granular.
• Better support for iframes/frames/nested documents
• Debug mode uses X2V for hCards and hCalendars
• Support for non HTML documents
• Bug fixes galore.

One feature I removed that I know people will complain about is the ability to have custom names for the actions. If I get enough complaints, I'll put this back.

IMPORTANT NOTE: This release uses new preferences so it will wipe out your old prefs. This should be the last time that happens. I also changed the location of user scripts so it won't pick up your old ones (they won't work anyway).

If you want new user scripts, check out: http://www.kaply.com/weblog/operator-user-scripts/

If you have user scripts you want to quickly port to Operator 0.8, please send them to me and I'll help.

Please report bugs here.

Have fun.

You might have heard from Elias Torres that we have RDFa working in Operator. You might also be wondering where that version is.

Basically I've been working very hard to finalize the APIs so that I can get things ready for Firefox 3. You can take a look at them here. The ironic part is that I've actually gone back to the way I wrote Operator the first time in terms of how microformats and actions are added to Operator. I'll be documenting this soon. And if you wrote to any of my other APIs, I'll work with you to move things to the new model.

So what do you have to look forward to in Operator 0.8a?

• RDFa support
• Unified action architecture (actions on the toolbar aren't specific to microformats)
• Support for non HTML documents
• A final architecture for actions and microformats so people can start coding to it
• Debug mode displays X2V output
• Export All available in "Microformats mode"
• Lots of bug fixes

Stay tuned. Just some fine tuning and we're good to go.

So let's talk about what Firefox 3 will hopefully offer for developers. The goal is that extension authors will have an API to access microformatted data directly without worrying about parsing. In addition, there will be a model for adding additional microformats, as well as adding semantic actions (more about that in a minute). Here's what the API looks like right now.

Any microformat can be instantiated from a DOM Node:

var hcard = new hCard(DOMNode);

Once the microformat has been instantiated, members can be accessed directly, like hcard.fn. If the property is defined as an array in the microformat specification, it is an array in the newly created object. A pointer to the original DOM node is also stored in this object if you want to do anything to the microformat node on the glass.

Microformat objects can be queried from a document:

var hCards = Microformats.get(document, "hCard");

I need a better name for this one I think. Given a document and a microformat type, this API returns an array of objects that represent each microformat in the document. I'm not sure if this should go through all the child frames and return every microformat in every sub document. I have to think about that.

If you have DOM Nodes, you might need some information about them. The scenario here is what if you have a DOM Node and you don't know if it is a microformat or not? What APIs could help you?

Microformats.isMicroformat(DOMNode)

This function tells you if the specific DOM Node you passed in is a microformat. It returns a boolean.

Microformats.getParentMicroformatNode(DOMNode)

This function gets the first microformat that is a parent of this node. If you pass in a microformat, it still gets the parent. This is important for finding nested microformats.

Microformats.getMicroformatNamesFromNode(DOMNode)

This function returns an array of the microformat types that this node represent.

So here's how you might use those three functions, for instance when a context menu is displayed on a given node:

  if (Microformat.isMicroformatNode(node)) {
    mfNode = node;
  } else {
    mfNode = Microformats.getParentMicroformatNode(node);
  }
  while (mfNode) {
    var mfNames = Microformats.getMicroformatNamesFromNode(mfNode);
    /* enumerate through names and do something */
    mfNode = Microformats.getParentMicroformatNode(mfNode);
  }

I mentioned semantic actions earlier. I'm still working on how I can create an action model that is easily extensible. In an earlier post, I suggested that actions be implemented like this:

semanticActions.actions.youtube_search_tags = {
  description: "Find videos on YouTube",
  icon: "http://youtube.com/favicon.ico",
  scope: {
    semantic: {
      "tag" : "tag"
    }
  },
  doAction: function(semanticObject, semanticObjectType) {
    if (semanticObject.tag) {
      return("http://youtube.com/results?search_query=" + encodeURIComponent(semanticObject.tag));
    }
  }
};

I'm now trying to decide if I should use a function method, something like:

semanticActions.addAction("youtube_search_tags", youtube_object);

There will be much more on that later.

Anyway, I'm primarily looking for feedback from people. Are these APIs sufficient? Did I miss something obvious? Thanks for the input.

I'm now the official owner of microformats support in Firefox 3. Here is the preliminary design document.

At this point, we'll primarily be focusing on making microformats available to extension developers, with very little UI. The primary motivator behind this is that I don't think anyone has come up with a good user interface for microformats. I want to take some time to bring up some different UI paradigms and have some general discussion on these ideas just to see what people think. We're actually trying to have a UI discussion on the labs forums, but we're not getting much input so I thought I would try here.

So far there have been multiple extensions with multiple ways to interact with microformats:

• Operator (toolbar, status bar button, toolbar button, right click on microformats)
• WebCards (in page "cards" - notifcation ribbon on the bottom of the screen, right click on microformats)
• Tails Export (sidebar)
• Tails (icon on the status bar - window presenting content of the microformats)

Some of the other ideas that have been floated have been using the Firefox notification bar to inform about microformats, in page highlighting of microformats, notifications on the URL bar similar to RSS feeds and changing the mouse pointer. You can see some of these ideas at Alex Faaborg's blog.

The primary concern we have in creating a microformats UI is that it's not necessarily something that is going to be accessed a lot (like a back button for instance, or bookmarks), so how much screen real estate should it take?

With Operator, my original plan was to allow for many different UI paradigms, and I'm continuing that in the next release by allowing individual buttons for specific microformats (a Contacts toolbar button for instance). So now I'm putting the question to you:

What UI paradigm for microformats do you prefer? Is there a paradigm you wish was in Operator (like a sidebar for instance)? What do you think microformats should look like in Firefox 3?

Feel free to come up with any wild idea you want.

In my next post, I'll be talking about what we should do for developers.

Since my original post on setting up a Firefox update server, I realized that some of my information was not correct. This post is to correct that information.

My mistake stemmed from the fact that the format of the Firefox update URL changed between Firefox 1.5 and Firefox 2.

Here's the URL for Firefox 1.5:

https://aus2.mozilla.org/update/1/%PRODUCT%/%VERSION%/%BUILD_ID%/%BUILD_TARGET%/%LOCALE%/%CHANNEL%/update.xml

Here's the URL for Firefox 2:

https://aus2.mozilla.org/update/2/%PRODUCT%/%VERSION%/%BUILD_ID%/%BUILD_TARGET%/%LOCALE%/%CHANNEL%/%OS_VERSION%/update.xml

You'll notice two differences:

1. The number after update was changed from 1 to 2 (this identifies which URL format to use)
2. %OS_VERSION% was added to the URL

The important change here is the addition of OS_VERSION. Whereas before, the update URL provided information only about the browser, with OS_VERSION, the URL now contains information that changes based on the machine on which the browser is running. This makes providing updates a little trickier (although not that much).

(Incidentally, the reason that OS_VERSION was added was so that the update server could detect Windows98 and Windows95 and not send them updates that didn't work on those machines.)

Let's present a modified .htaccess file that handles this situation. I'm going to assume that in your enterprise deployment, you don't care about OS_VERSION, so we are just going to ignore it. In our original .htaccess file, we simply checked for the existence of update.xml in a path that corresponded to the URL. Because of the addition of OS_VERSION, that won't work anymore, since we would have to duplicate the update.xml file based on every possible OS_VERSION that could be sent to us. So we need to create a .htaccess file that ignores OS_VERSION. The way we do this, is simply redirect the URL to a new URL that doesn't contain OS_VERSION, and then use our old method of checking for the existence of a file.

RewriteEngine on

RewriteRule ^(.*)/release/(.*)/update.xml /$1/release/update.xml [R]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*) noupdate.xml

What this says is if the URL contains something between release and update.xml (OS_VERSION), remap it to remove the OS_VERSION. Then send it to the server again.

I'll leave updating the PHP script as an exercise for the reader.

I hope this clears up any issues with my original post.

One of the things I've been trying to finalize for the next release of Operator is the action architecture. Here's what things look like now.


ufJSActions.actions.corkd_search_tags = {
  description: "Find wines on Cork'd",
  icon: "http://corkd.com/favicon.ico",
  scope: {
    semantic: {
      "tag" : "tag"
    },
    url: "http://corkd.com"
  },
  /*
   * Perform an action
   *
   * @param semanticObject JavaScript representation of the semantic object
   * @param semanticObjectType Semantic object type as a string
   * @param domNode DOM Node associated with the semantic object
   * @return If you return a value, we attempt to open it as a url
   */
  doAction: function(semanticObject, semanticObjectType, domNode) {
    if (semanticObjectType == "tag") {
      if (semanticObject.tag) {
        return("http://corkd.com/tags/" + encodeURIComponent(semanticObject.tag));
      }
    }
  }
};

First let's talk about scope. Semantic scope is about indicating which microformats (and in the future other semantic data) this actions works with. On the left is the type of semantic data, on the right is the required value. So for instance, if you had an action that worked on hCalendar and required a dtstart, it would be "hCalendar" : "dtstart". You can use url to specify that an action should only be displayed when you are on a certain web page.

Next, let's talk about the action itself. When you return a value from an action, we assume it is a URL and open it. If you want to do your own thing (like export a vCard), you can do arbitrary JavaScript and just return. I'm also working on a "doActionAll" which will allow on action to act on all microformats of a given type on a web page.

What do people think of this overall design? Is it simple enough to encourage anyone to write actions? Am I missing anything obvious?

So it ended up that it wasn't that easy to switch our installer to use "Product Version" to determine what version of Firefox was installed, so I was asked to provide information on how to use the Windows Registry to determine the installed version of Firefox. Since that information is useful to everyone, I thought I would post it here.

The following registry path is where Mozilla Firefox info is contained:

HKEY_LOCAL_MACHINE\SOFTWARE\Mozilla\Mozilla Firefox

(Note that Firefox 1.5 and below used to put information in HKEY_CURRENT_USER as well. Firefox 2 does not.)

Within this registry path, there is a key, CurrentVersion. This key indicates the installed version of Firefox as well as the locale. Don't confuse this with HKEY_LOCAL_MACHINE\SOFTWARE\Mozilla\CurrentVersion which is something else entirely.

If you need to locate the installation, there is a key under Mozilla Firefox with the same name as CurrentVersion. That key contains another key called Main that has a value for the install path (Install Directory).

Incidentally, in the screenshot, you might notice that other folder, Mozilla Firefox 2.0.0.3, which has subfolders called bin and extensions. That's there for posterity. A long time ago, we told people that to find the plugins directory, concatenate the product and version together and then look for the plugins key as a child of that key. If I remember correctly, that's how it was done even in the Netscape Navigator 2/3 days. You can read more detail about those keys on MDC.

Unfortunately for everyone out there, when I discover new things in JavaScript, it means I rewrite some parts of Operator, and I am in the middle of that right now. The thing that I discovered is the ability to have custom getters for objects in JavaScript.

One of the things I have wrestled with in the past is that my current model for accessing a microformat in JavaScript is clunky. You have two choices - you can either create the microformat in its entirety:

var hcard = createMicroformat(node, "hCard");

and access the properties like this:

alert(hcard.fn);
alert(hcard.adr.region);

or you can access an individual property like this:

var fn = getMicroformatProperty(node, "hCard", "fn");

The problem with the first approach is that you do a lot of work if you only want part of the microformat, and the problem with the second approach is that there is no caching of the data.

Enter custom getters:

var hcard = new hCard(node);
alert(hcard.fn);

and hcard.fn is not queried until you access it the first time and it is cached.

What I do now is that when the hCard is instantiated, I set the getter for each property to be a function that queries the property and then sets it (getMicroformatPropertyGenerator):

object.__defineGetter__(property, ufJSParser.getMicroformatPropertyGenerator(node, microformat, property, object));

getMicroformatPropertyGenerator looks like this:

getMicroformatPropertyGenerator: function(node, name, property, microformat)
  return function() {
    var result = ufJSParser.getMicroformatProperty(node, name, property);
    if (result) {
      microformat.__defineGetter__(property, function() {return result});
      return result;
    }
  };
}

The result allows for much cleaner code in an action, because the actions are now going to receive the microformat data object directly so they don't have to worry about DOM nodes and things like that. All an action has to do is access the individual properties. This will also allow for actions that aren't so dependent on microformats.

I'll still keep the old way around if people want to use the microformat parser in web pages. If anyone knows of a cross browser way to do what I am doing, or even a better way to do it, please let me know.