yuriy.org

Building a Modal Popup Framework with Silverlight

2009-01-17T23:07:00.000-05:00

This post will demonstrate one way to create a modular and flexible framework for endowing your Controls with the ability to pop up in modal and non-modal modes.

Goals:

Allow any Control to be "popped up" in modal and non-modal modes
Construct a framework that is modular and made up of discrete, reusable components
Properly hide implementation details and expose a simple api for developers to utilize.
Reduce the amount of customization to the framework required by front-end developers.

Deconstructing the modal framework:
When modeling the framework, I thought it appropriate to use a framed painting as a metaphor.

A frame can enclose any painting. The frame itself can be reused.
A painting can be any painting. As long as it's a "painting" we can frame it.
A framed painting can be hung on a wall.

And so, the modal framework should be modeled similarly:

We want a generic "frame" control that provides possibilities to adorn the frame with elements as well as the ability for the frame control to enclose any other silverlight control.
The "painting" is any silverlight element that subclasses FrameworkElement. This covers (all?) user and custom controls.
A Dialog factory is responsible for assembling the frame, the painting, and most importantly for providing the modal or non-modal popup behavior for the assembled "painting".

The code along with a demo exercising the popups is available for download from: http://yuriy.org/downloads/org.yuriy.Silverlight.DialogFramework.zip. It is released under LGPL and I hope it is useful. The code is decently well documented and I encourage you to explore the implementation. Of course, please contact me with any errata or feedback.

Implementation Design

AbstractFrame - is a custom control comprised of a c# class and associated templating in Themes/generic.xaml. It is the proverbial "frame" as described in pt 1 above. Its two responsibilities are:

Establish default layout for Header, Body, Footer place holders - ContentPresenters exposed as custom DependencyProperties.
Establish a default theme for our dialog popup.

Imagine that our corporate the branding team already decided on a standard look'and'feel for all dialog popups. We style our generic frame here so that all components utilizing this one get our desired default style for free.

Additionally, the exposed ContentPresenters grant the developer the "right" amount of flexibility. Let's refer to this as "Guided Development".

FrameImpl - FrameImpl is not a true "implementation" of an abstract class because AbstractFrame is not an "abstract" class. In fact, both subclass ContentControl. In a way, Abstraction and Implementation are be modeled in XAML through the use of Dependency Properties and what I'll refer to as Wrapping. If you take a look at generic.xaml, you will notice that the template for FrameImpl is nothing more than an AbstractFrame declaration with the Header and Body ContentPresenters further defined. This wrapping behavior is, in a sense, akin to subclassing in OO.

Through quite a few hours of exploration, I can state that Controls development in Silverlight favors Composition over Inheritance. Perhaps FrameImpl should have simply assembled three or four individual Controls rather than declare the details of Header, Body and Footer as part of the wrapper. In any case, to maintain my initial metaphor, I favored Inheritance.

As stated earlier, the inheritance happens in XAML, NOT within the code-behind classes. Both FrameImpl and AbstractFrame subclass ContentControl so that Silverlight can guarantee correct binding to XAML.

Buttons and event handlers in FrameImpl
One of the important details in FrameImpl's is the declaration of Buttons, a single mechanism for handling button clicks, and a chaining mechanism that notifies the caller of a button click. Control is returned to the caller with an enum click status and a reference to the included control for easy post-processing that is decoupled from the implementation of the buttons itself.

Again, the layout, styling and available customizations are configured for desired default behavior and the available interface to the developer is reduced to simplify possible and appropriate customizations.

The buttons in this demo are specified as a Close Button in the upper right corner, and a ribbon of optional and configurable "left", "center", "right" buttons that can be used to model most common dialogs. The developer has the option to hide any or all of the buttons. Again, all the buttons are prewired. The developer just needs to specify an event handler when working within this framework.

DialogFactory
The final stage of my implementation is a Factory that:

Exposes static Show() initializers to the developer. These are overloaded for button config flexibility, accept any Silverlight control as content for the popup, and an event handler to receive notifications of buttons clicks within the Dialog. These are contained in the DialogFactory.static partial class.
The DialogFactory.effects partial class contains methods that contain point math for dragging of the dialog across the screen as well as resizing and centering the Dialog. Although not currently implemented, this partial class can also contain entrance and exit animation effects.
The DialogFactory partial class contains the internal constructor, and processors for configuring buttons, handlig events, configuring modality and so on. DialogFactory appropriately delegates control to FrameImpl and binds app developer's handlers to events generated by FrameImpl.

DialogFactory has no associated XAML. It is purely a C# factory that uses the Popup primitive alongside a masking Canvas and a draggable Border to provide the modal popup behavior for any passed in Control. The Control is, of course, wrapped in a FrameImpl.

As a side-note, DialogFactory does account for a known Popup/Pulldown bug that causes Silverlight to crash.

Project Structure
The Solution is split into three Projects:

Controls lib - the framework is contained in a standalone controls dll. It needs to be referenced in your projects. If you are implementing controls for your company, odds are they are in a separate library so that multiple apps can use them. The idea is the same here, even though this demo only has one control!
A Silverlight App - this contains a DialogDemo UserControl that exercises the DialogFramework.Show() istantiators and some sample Controls to be passed into the initializer.
ASP.NET project - this is the project that loads (2).

Run the Demo

Download the code and open it in VS.
Make sure that the ASP.NET project is set as the executing default. A form that allows you to play with DialogFramework will come up with your browser.

The Code. The code!
Again, you can download the code from: http://yuriy.org/downloads/org.yuriy.Silverlight.DialogFramework.zip. It is released under LGPL. I believe it is decently well documented and provides insights into my implementation choices.

Acknolwedgements
This was my first deep dive into Silverlight. I read articles from many developers. The work I present here is a synthesis of great work from several authors, notably:

A Solution to DataGrid with Tooltips Shortcomings

2008-12-26T20:05:00.028-05:00

DataGrid with a Custom RowDetailsTemplate
Silverlight RTM has a DataGrid control. To learn more about basic usage, please refer to http://blogs.msdn.com/scmorris/archive/2008/03/21/using-the-silverlight-datagrid.aspx

Beyond the basics, DataGrid has a few shortcomings. Let's say we have a static DataGrid declaration that looks like this:

Where the ItemsSource of the DataGrid is defined by a List collection:


public class GridData
{
 public int ID { get; set; }
 public string FirstName { get; set; }
 public string LastName { get; set; }
 public int Age { get; set; }
 public bool Available { get; set; }
}

DataContext of Grid not associated with ToolTip's DataContext by default
The first annoyance is ToolTip does not inherit the DataContext (entry in the List) associated with the Row that contains it. Compiling the above code will result in the Record # binding picking up the correct Binding while the custom ToolTip.Content will not.

The Solution is to add a handler for a Loaded Event to the Grid that begins our DataTemplate definition:

 
 <grid loaded="Grid_DataContext_Fixer">
  <tooltipservice.tooltip>
   <tooltip></tooltip>
  </tooltipservice.tooltip>
 </grid>

Inside the handler, we use the ToolTipService to manually set Grid's DataContext to the DataContext of the Tooltip like so:


private void Grid_DataContext_Fixer(object sender, RoutedEventArgs e)
{
 ToolTip t = ToolTipService.GetToolTip(sender as Grid) as ToolTip;
 t.DataContext = (sender as Grid).DataContext;
}

The ToolTip will now properly understand the binding.

Sorting DataGrid will break ToolTip associations
When user sorts the DataGrid ToolTips are not re-ordered along with the view.

Why this happens is not clear. ToolTipService does bind to the right Object reference yet the DataContext remains tied to the ordering of items in the original List.

A Solution. This time we add a MouseEnter event handler to the same Grid.


<grid loaded="Grid_DataContext_Fixer" mouseenter="Grid_DataContext_Fixer">
<tooltipservice.tooltip>
 <tooltip>...</tooltip>
</tooltipservice.tooltip>
</grid>

In fact, the MouseEnter event will do exactly the same thing as before. Namely, the Grid's context will be reassigned to the Tooltip. As shown above, we handle both events with the same handler.

We now get expected behavior.

If you have a better solution, please do provide feedback in the Comments.

Twitter is Google Search in Reverse

2008-12-18T01:26:00.007-05:00

Remember the search interfaces of yester-years? Pulldowns, check boxes, and operands defined the experience until Google stripped it all away. The exposed input box felt naked next to its companions. Yet the babe had brawn. Over the years the ubiquitous search box came to dominate content retrieval because of its simplicity, expressiveness, and relative clairvoyance. You typed some text in, Google rewarded you with a best guess of information you must have been looking for.

Our utterly selfish "give me" relationship with Google quickly earned Google medals in advertising. We were still putting enough "in" to Google's Engine for it to quasi-cleverly match up your key words with the highest-bidding, and content-relevant advertiser.

Spin up to today and we have a similar input box delivering 140 characters of further indulgence. "Give me" seemed to evolve social consciousness into an "I am". Our passive-aggressive social cloud is bloated with micro-summaries of people's whereabouts, whatchados, grandiose plans colored by nuance and mediocrity. And what with it? Nothing. Or rather nothing much.

Those still riding the web2.0-enabled Collaboration and Productivity opportunities are escaping email for what they hope to be a Twitter-gendered repose from Info Glut. But this is naivete. Every medium for communication will only alleviate over-saturated predecessors until usage turns into abuse-age. A much savvier colleague of mine had an insight that, paraphrased, in the consumer world, Twitter creates communication where it does not already exist. In the workplace, however, we are trying to better direct our information traffic, to reduce abuse, to improve relevancy, and tune interruption.

Twitter is a cloud of unstructured data. This data is time sensitive. A classical use case is "What am I doing now?". Stretched a bit we can evolve to "I am planning something right now that I will do shortly" and "I have just done something stranger and friends alike should know about".

As is, this glorified presence system is prime for integration with our Instant Messaging Clients' Status Notes or Away Message. But this is not very exciting. As the significance of any single Twitter fades with passing seconds into oblivion, what are we, the Information Workers, gaining from such an exchange? A Status Feed is great, but really, just the tip of the ice berg.

Sometimes actual Knowledge is Twittered. For example, "I just read a great article on Silverlight about Animations at http://..." or "Firebug just crashed on me after visiting a site with Google Ads again!".

The first sample is clearly relevant to people interested in Silverlight. The second is clearly a bug report and a stability alarm. Perhaps unfiltered noise in the consumer cloud but in the Enterprise access to these streams of consciousness is the very essence of the next generation's competitive edge.

And so Twitter must become the reversed flow of Google-like search.

In the Enterpise, search blankets our repositories and knowledge bases, constructing a uniform way for retrieval. Twitters (micro-content, really) must be deconstructed and filed back in. To be able to distinguish Status from Knowledge and to create on-demand availability of this type of information mashed up with related information is the cosmic pixie dust of the future.

Speaking of the future, Twitter recently acquired Values of n for I Want Sandy, a personal digital secretary. If Twitters about "right now" generate Knowledge then Twitters about the future must generate Activities. Activities produce Knowledge: more Twitters, CRM information, documents, blog posts, etc. When all this information is accounted for it truly seems that the personal Digital Assistant need not be so personal after all.

To move beyond this "give me" towards a notion of Coordinated Intelligence, we will need to embrace Semantics, Context, Community-friendly Knowledge Management strategies, and that bit of nakedness. I'll race you there.

Silverlight RC0 Custom Controls: App.xaml vs Generic.xaml

2008-09-29T09:08:00.027-04:00

Motivation
Silverlight 2 RC0 is now available to developers and early adopters. Summary of release and Breaking Changes are reproduced in my previous post available here.

Best Practices around developing Custom Controls is still a shaping story. Many tutorials currently available on the web prefer the use of App.xaml or the UserControl itself for custom styling and templates. In fact, Styles and Templates are still a bit confusing from a design and usage perspective.

The existence of yet another option, the use of generic.xaml further confuses approach to styling. For those of you who have been scratching their heads as much as I have been, I hope that the basics I'll outline in this and future posts will help the Silverlight community refine the "right" way approach Custom Control creation, Styling, and Templating.

Goals
• Propose strategy for using Generic.xaml and App.xaml
• Project structure should enable Control Designers, Control Developers and Application Developers to work independently of one another.
• Create a single Silverlight Control library of reusable Custom and User Controls, each with customized Look-and-feel.
• Look-and-Feel of each control needs to be "baked in" so that they can be used "as is" by our Application.
• Controls should still be open to further styling and customization by the Application Developer at the application layer.

Requirements
VS 2008 SP1, .net 3.5 SP1, Silverlight Tools with RC0 builds + SP1. For download locations, see my previous post here.

Setup
• a Silverlight Class Library called YControlsLib
• a SilverlightApplication called YControlsDemo
• allowed VS2008 to automagically generate a YControlsDemo.Web asp.net project to host YControlsDemo project

Download The Solution
The solution is available here for download.

YControlsLib
Here, I will wear the Control Developer and Control Designer hats. The simplest control to play with, in my opinion, is the Button control.

Controls can fall into three categories:
1. Combine two or more basic controls into a single control
2. Enhance a single, existing control
3. Create something completely new from scratch

My custom Button resides in the 2nd category.

Because I am simply enriching an existing control I decided to subclass Button and create my own Custom Control, called Ybutton. I will customize Button's look-and-feel. Idea is to be able to use Ybutton with its custom style out-of-the-box in my Application, without the need to override the Button's template.

Although subclassing does not always make sense, I do feel that there are clear benefits in this case:
• For Application Developer, encapsulates control functionality and branding
• Clearly differentiates your organization's control from the default
• Allows you to customize certain behaviors of the control without modifying the original
• Provides some protection against changes to the original control. Subclassing or Wrapping (the former in this case) is perhaps an enterprise-friendly approach.

I started with a simple .cs file without any XAML files. This is what we can refer to as a lookless control stub.

YButton.cs

namespace YControlsLib
{
public class YButton : Button
{
  public YButton()
  {
     this.DefaultStyleKey = typeof(YButton);
  }
}
}

DefaultStyleKey is important. This is the only line of custom code needed to bind my custom Button to my custom Template. This template is defined in generic.xaml.

Themes/generic.xaml
As per the Breaking Changes document, generic.xaml needs to reside within the Themes folder. Your Application will not recognize the template binding if this file lives anywhere else.

There is no template in VS for creating this file. I just create a text file and modify its extension. Also, it has to compiled as a Resource (not an Embedded Resource) for runtime and Blend to know what to do with it. More on Blend later.

Here is the basic layout:

YControlsDemo/Page.xaml
Page.xaml is authored by the Application Developer. All Controls required for this project are made available to the App Developer via Silverlight's Default Controls library and the Controls provided by the YControlsLib dll. For simplicity, the YControlLib project is simply referenced from YControlsDemo.

Page.xaml is the typical UserControl which defines one View from our Application. Our App is effectively just a Demo of three Controls:
i. Default Button
ii. My custom button, Ybutton
iii. Ybutton with a tweak from App Developer

Page.xaml only contains:

 <UserControl x:Class="YControlsDemo.Page"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:ycontrols="clr-namespace:YControlsLib;assembly=YControlsLib">
 <StackPanel x:Name="LayoutRoot" Background="White" Orientation="Horizontal">

<!-- (i) This is just a plain ol' boring Button -->
<Button Width="100" Height="45" Content="Button"/>

<!-- (ii) YButton inherits everything from above Button but also contains it's own
template.  Because the custom  template is inherent to the control, App
Developer can use it as is -->
<ycontrols:YButton Width="100" Height="45" Content="YButton"/>

<!-- (iii) This is a YButton with a custom Style that App Owner defines in App.xaml.
Useful for disobeying your company's Branding guidelines -->
       <ycontrols:YButton Width="100" Height="45" Content="Ybutton Style"
       Style="{StaticResource TweakedYButtonStyle}"/>

<!-- (iv) This is a YButton with a custom DataTemplate -->
<ycontrols:YButton Width="100" Height="45"
ContentTemplate="{StaticResource YButtonCustom}"/>
 </StackPanel>
</UserControl>

Since we have not yet completed Ybutton with it's custom Template nor defined any custom Style, our Designer will only show us the default Button:

Back to Themes/generic.xaml
We now need to wear the Control Designer hat. For this, we need to use Expression Blend. The SP1 Preview still does not handle Generic.xaml too well. Because my YButton Control is lookless, Blend will not understand that I want to create a custom template and keep it in Generic.xaml.

For a bit of a work-around, I created a UserControl (similar to Page.xaml) called ControlsForBlendsBenefit.xaml. This goes directly into the YControlLib project. This item will contain a plain Button and my Ybutton.

ControlsForBlendsBenefit.xaml

 <UserControl x:Class="YControlsLib.ControlsForBlend"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 Width="400" Height="300"
 xmlns:local="clr-namespace:YControlsLib;assembly=YControlsLib">
 <StackPanel x:Name="LayoutRoot" Background="White" Orientation="Vertical">
    <Button Width="100" Height="45" Content="Button"/>
     <local:YButton Width="100" Height="45" Content="YButton"/>
 </StackPanel>
</UserControl>

The Button is there so that I can "Edit a Copy" of it's default template within Blend. I will be tethering this modified copy to YButton, making it the Default Template.

Now, I right-click on the xaml file and "Open in Expression Blend..."

Now, Right-Click on Button and select to "Edit a Copy…" of the Button's template.

We'll be doing moving generated content around anyway, so where we put the Copy of Button's default template is not very important. I'll put it within ControlsForBlendsBenefit.xaml.

Notice that the dialog below is asking me for a Name/Key. This is the Key that allows an Application view to specify a Style={StaticResource ButtonStyle1}. This is where things get a bit confusing. Silverlight provides two ways of overriding Look-and-Feel of controls. One is through a replacement of the Template itself, or one by simply Key-ing a new Style. The Style can reside within App.xaml or in a more localized location, the UserControl, or even more scoped, within the Control itself. The way that Blend generates this Style, the Style will contain the copy of the Template. My Button will have to use the Style attribute to access it. This is not what we want. But for Blend's sake, we'll work through it this way.

If we peek into the code of ControlsForBlendsBenefit.xaml we'll see something like:


<UserControl x:Class="YControlsLib.ControlsForBlend"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 Width="400" Height="300"
 xmlns:local="clr-namespace:YControlsLib;assembly=YControlsLib" xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows">
<UserControl.Resources>
<Style x:Key="ButtonStyle1" TargetType="Button">
<Setter Property="Background" Value="#FF1F3B53"/>
<Setter Property="Foreground" Value="#FF000000"/>
<Setter Property="Padding" Value="3"/>
<Setter Property="BorderThickness" Value="1"/>
<Setter Property="BorderBrush">
 …

After customizing these pieces from Blend, it is the code block beginning with that will make its way over to Generic Xaml. In fact, we can do so now and continue editing from within generic.xaml. Perhaps, for the final release, the Silverlight team will make working with generic.xaml a bit more straight-forward.

Generic.xaml Revisited
This file will now include a copy of Button's default Template:


<ResourceDictionary
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="clr-namespace:YControlsLib;assembly=YControlsLib">
 <Style x:Key="ButtonStyle1" TargetType="Button">
…

You will notice many prefixes adorning VisualState prooerties in the newly crafted generic.xaml . Visual Studio does not like these. They are relics left behind by Blend. Looks like it is yet another quirk that the Silverlight Team needs to work out. A forum post for this is here: http://silverlight.net/forums/t/23959.aspx. I'll just "Quick Search/Replace" the "vsm:" bits into nothingness.

The last bit of work to complete here is to remove the generated UserControl.Resources and Style markup from the ControlsForBlendsBenefit.xaml. Remember, we are not going for inline styles. We want to override Ybutton's default Template.

If you are switching between VS and Blend, you may need to recompile your Project in VS for the new generic.xaml to properly expose Templates within Resources tab in the upper right corner.

Once Blend reload the project you should now see something like this:

We will be Editing the ButtonStyle1 resource from now on. After selecting the Resource for Edit (right-most button along-side the ButtonStyle1), we can click on the icon in the left-most corner and "Edit the Template" itself.

We should now see all the Parts and States of the Button Template we will be customizing.

I'll simply customize some gradients to give this Button template an overall Orange hue.

Finally, the last step is to apply the Style and Templates to YButton only. This is done by replacing TargetType="Button" with TargetType="local:YButton".

Themes/generic.xaml is now:

 <ResourceDictionary
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="clr-namespace:YControlsLib;assembly=YControlsLib">
 <Style TargetType="local:YButton">
     <Setter Property="Background" Value="#FF1F3B53"/>
     <Setter Property="Foreground" Value="#FF000000"/>
     <Setter Property="Padding" Value="3"/>
     <Setter Property="BorderThickness" Value="1"/>
     <Setter Property="BorderBrush">
         <Setter.Value>
             …
         </Setter.Value>
     </Setter>
     <Setter Property="Template">
         <Setter.Value>
             <ControlTemplate TargetType="local:YButton">
                 <Grid>
                     …
                 </Grid>
             </ControlTemplate>
         </Setter.Value>
     </Setter>
 </Style>
</ResourceDictionary>

Editing Styles in App.xaml
After rebuilding the solution, we should now see the following in the ControlsForBlendsBenefit.xaml:

The markup inside is simply:


<UserControl x:Class="YControlsLib.ControlsForBlend"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 Width="400" Height="300"
 xmlns:local="clr-namespace:YControlsLib;assembly=YControlsLib" xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows">

 <StackPanel x:Name="LayoutRoot" Background="White" Orientation="Vertical">
    <Button Width="100" Height="45" Content="Button"/>
     <local:YButton Width="100" Height="45" Content="YButton"/>
 </StackPanel>
</UserControl>

Notice, there is no Styling within the View. We have successfully encapsulated the custom template to the YButton Custom Control!

Back to our YControlsDemo
YControlsDemo simply references the YControlsLib as a DLL containing our Custom Controls. The code of our Page.xaml is still:

 <UserControl x:Class="YControlsDemo.Page"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:ycontrols="clr-namespace:YControlsLib;assembly=YControlsLib">
 <StackPanel x:Name="LayoutRoot" Background="White" Orientation="Horizontal">
     <Button Width="100" Height="45" Content="Button"/>
     <ycontrols:YButton Width="100" Height="45" Content="YButton"/>
     <ycontrols:YButton Width="100" Height="45" Content="YButton2"
Style="{StaticResource YButtonStyle}"/>
 </StackPanel>

</UserControl>

But now the Preview shows us:

I will simply rotate the Button a bit and change the Background gradient. My end-result is:

Extra Credit: Editing the Ybutton's DataTemplate within App.xaml
The last tweak I will introduce is one introducing DataTemplate. Plain ol' Button has a simple TextBlock at its heart. What if I want something a bit more expressive while retaining the overall Template and Style of the Ybutton?

Solution is to use Blend to only Edit the DataTemplate of the 4th Control.

To keep things simple, I only introduced a two-column Grid layout with an Elipse in the first Column and a static TextBlock in the second Column.

Resulting manifestation of YButton is:

App.xaml
The resulting App.xaml in YControldDemo is then:

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       x:Class="YControlsDemo.App"
       xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
       xmlns:YControlsLib="clr-namespace:YControlsLib;assembly=YControlsLib" xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows"
       >
<Application.Resources>

<DataTemplate x:Key="YButtonCustom">
<Grid ShowGridLines="False">
 <Grid.RowDefinitions>
  <RowDefinition Height="Auto"/>
 </Grid.RowDefinitions>
 <Grid.ColumnDefinitions>
  <ColumnDefinition Width="40"/>
  <ColumnDefinition Width="60"/>
 </Grid.ColumnDefinitions>
 <Ellipse Grid.Row="0" Grid.Column="0" Margin="5,0,5,0" HorizontalAlignment="Stretch">
  <Ellipse.Fill>
   <RadialGradientBrush>
    <GradientStop Color="#FFF4F3ED"/>
    <GradientStop Color="#FFE27259" Offset="1"/>
   </RadialGradientBrush>
  </Ellipse.Fill>
 </Ellipse>
 <TextBox Text="Click Me" TextWrapping="Wrap" Grid.Row="0" Grid.Column="1" Background="{x:Null}" BorderBrush="{x:Null}"/>
</Grid>
</DataTemplate>

<Style x:Key="YButtonStyle" TargetType="YControlsLib:YButton">
...  
</Style>

</Application.Resources>
</Application>

Done.
Rebuilding the solution, our Silverlight RC0 Demo App looks like:

Conclusion
In this post, I've attempted to exercise three of multiple roles commonly played on a large project:
1. Control Designer
2. Control Developer
3. Application Developer

Using both Visual Studio 2008 SP1 + Silverlight Tools as well as Expression Blend RC0 Preview, I subclassed a regular Button so as to completely encapsulate a custom Look-and-Feel for my version of the Button without having to re-instrument the entire control. Through the use of Generic.xaml in the Themes folder of my Control Lib, I was able to specify my custom Template and Styling for my button while giving the Application Developer a simple Control, YButton.

I also submitted a bit of extra credit by demonstrating how Application Developers retain flexibility to further modify Data Templates and the Content Templates of Custom Controls within App.xaml.

So what is App.xaml vs Generic.xaml. Generic.xaml is a compiled Resource. Silverlight is hardwired to look for default Templates within Generic.xaml. It is ideal for providing custom templates for a Control Lib. It will travel with the Control Lib without the need for further intervention by the Application Developer. It permits custom control look-and-feel out-of-the-box. App.xaml is simply a scoping mechanism for providing nuance Styling and Templates for the given Application only. To port Styles and Templates within App.xaml to other application, one would have to copy over App.xaml itself.

Hope this helps shed additional light on Custom Controls, the Silverlight 2 RC0 way! If you wish to download the entire Project, the zip archive is available here.

Related Articles from fellow Bloggers
I've spent much time reading other great Blog entries. Some of them are below:

Silverlight 2 RC0 is here!

2008-09-28T16:47:00.002-04:00

RTM is a month away

Silverlight 2 RC0 is here, or rather here, which means that RTM is less than a month away! Developers are asked to gain a head start on remediating Beta 2 applications. For convenience, the links and Breaking Changes details are reproduced here.

Silverlight 2 RC0 Tools for Developers

Microsoft Silverlight Tools for Visual Studio 2008 SP1

This will install the necessary Visual Studio updates, Silverlight project templates, RC0 developer runtime, and SDK.
Microsoft Expression Blend 2 Service Pack 1 Preview

This version of Expression Blend is targeted to work with the RC0 developer runtime for Silverlight.

Breaking Changes Since Beta 2

This topic discusses the changes made to the Silverlight runtime and Silverlight tools between the Microsoft Silverlight 2 Beta 2 and the final release of Silverlight 2. The changes discussed in this article are focused on changes that might cause your older Silverlight-based applications to now fail or behave differently, not on new features/enhancements for this release.

Note Corrections/Additions to this document (if any) are listed here.

Note Applications built with Beta 2 will not run on final runtime builds. End users will see a message informing them that the application was built with an obsolete version of Silverlight. You must rebuild your Beta 2 applications – see here for more information.

Tip Given the large number of API changes, particularly those listed in the Miscellaneous API Changes section, you may want to search this document by using CTRL+F.

Contents:

Important! Migrating Older Code to the Newer Release
ContentPresenter now derives from FrameworkElement instead of Control
Layout Rendering Slightly Changed
Cross domain hosts of Silverlight must set the right MIME type for XAP (application/x-silverlight-app)
Exceptions now thrown in HttpWebRequest.EndGetResponse()
Font URI is Restricted to Assembly Resource
Browser.HtmlElementCollection replaced with by Browser.ScriptObjectCollection
Exceptions When Changing Some Properties on an Active Animation
System.Windows.Controls.Extended.dll renamed to System.Windows.Controls.dll
VisualStateManager Changes
KeyDown Sent Synchronously
MeasureOverride/ArrangeOverride on Canvas Now Sealed
UriTypeConverter moved to System.dll
HtmlPage.UnregisterScriptableObject Removed
RenderingEventArgs Changes
ContentPresenter and ContentControl Changes
Removal of FileDialogFileInfo Type and OpenFileDialog.SelectedFile(s) Properties
Removal of FullAccess Option on the ExternalCallersFromCrossDomain attribute in the Silverlight 2 application manifest
KeyFrameCollection Changes
Request stream must be closed before calling HttpWebRequest.BeginGetResponse()
HtmlWindow references on Safari/Mac will no longer evaluate to true
Address property removed from all WebClient EventArg classes
Constructors Made Internal
Exception type change for System.Xml exception type
Cannot create classes in XAML that do not have accessible constructors
Get AG_E_UNKNOWN_ERROR in Silverlight 2 but not in Silverlight 1
Platform looks for generic.xaml as a resource at themes/generic.xaml
HTTP Polling Duplex OM Changes and Reengineering
Breaking change to Silverlight native hosting IXcpControl COM interface
Content-Type is allowed on cross domain request by default
Enforcing delegate type check when two delegate objects are combined
Miscellaneous API Changes

Important! Migrating Older Code to the Newer Release
If you are migrating Silverlight applications that were created for the Silverlight 2 Beta 2 release or earlier to the final release of Silverlight 2, you are going to need to get the newest Silverlight 2 Tools for Visual Studio 2008 and recompile your project(s).

Get the newest version of Silverlight 2 Tools for Visual Studio 2008. You can get these tools from the SDK or online at Getting Started. You may have to uninstall any old tools before doing this install.
Open your old project (e.g. .csproj file). A dialog will come up notifying you that your project was created with an older version of Silverlight tools and asks you if you want to upgrade your project. Click the Yes button.
Open all of the HTML files and change:

The Silverlight MIME type from application/x-silverlight-2-b1 or application/x-silverlight-2-b2 to application/x-silverlight-2.
The Silverlight installation URL from http://go.microsoft.com/fwlink/?LinkID=108182 or http://go.microsoft.com/fwlink/?LinkID=115261 to http://go.microsoft.com/fwlink/?LinkID=124807.

Note: some templates replaced http://go with http://go2. Be sure to search for both.
Debug. Many of the breaking changes you are likely to encounter can be found in this document.

ContentPresenter now derives from FrameworkElement instead of Control
Who Is Affected: Applications that use ContentPresenter or objects derived from ContentPresenter.
Summary
Because ContentPresenter now derives from FrameworkElement, the following properties are no longer exposed by ContentPresenter:
Background
BorderBrush
BorderThickness
DefaultStyleKey
FontFamily
FontSize
FontStretch
FontStyle
FontWeight
Foreground
HorizontalContentAlignment
IsEnabled
IsTabStop
Padding
TabIndex
TabNavigation
Template
VerticalContentAlignment

In addition, some APIs were removed from ContentPresenter (see ContentPresenter and ContentControl Changes).
Fix Required
Remove all these obsolete properties from your ContentPresenter objects, which will likely require you to re-work some of your code to restore your previous UI rendering.

Layout Rendering Slightly Changed
Who Is Affected: All content using layout might be rendered slightly differently because layout no longer causes elements to be rendered at sub-pixel locations.
Summary
The layout system in Silverlight has been modified to round final measure and arrange values to integers when placing elements on the screen ("pixel snapping"). The result is crisper lines, more consistent rendering look, and fewer rendering artifacts.
Layout rounding will be *on* by default, but there is a new inherited property on UIElement called UseLayoutRounding that can be set to false if the old layout behavior is desired.
Note It is possible that this change will affect how your animations render, in which case you might want to set UseLayoutRounding to false.
Note This change does not affect transforms. If you apply a transform to an element, it may still be rendered at a sub-pixel location.
Cross domain hosts of Silverlight must set the right MIME type for XAP (application/x-silverlight-app)
Who Is Affected: Anyone serving Silverlight 2 apps from cross domain:
Via a web server that is not IIS7
Via a web server where the MIME type for .XAP files is incorrectly configured

Summary/Fix Required
When the XAP is served from a different domain than the host HTML page, Silverlight will validate that the MIME type (Content-Type response header) returned on the HTTP response is application/x-silverlight-app.
Apache (and perhaps other servers) tend to serve unrecognized content as text/plain, and therefore will be affected by this change. You are required to add an entry for the Silverlight XAP MIME type to your .htaccess file -- e.g. AddType application/x-silverlight-app xap.
Note IIS7 shipped with the right MIME type configurations for Silverlight XAPs. No action is required if you are using IIS7.
Exceptions now thrown in HttpWebRequest.EndGetResponse()
Who Is Affected: Silverlight 2 applications that use HttpWebRequest.
Summary/Fix Required
For HttpWebRequest:
Before:
Some security exceptions (e.g. cross-scheme violations) were being raised in HttpWebRequest.BeingGetResponse()
All other request error conditions were being returned as 404s.

Now:
Error conditions are now raised as exceptions in HttpRequest.EndGetResponse().
- Request security errors (e.g. requests not allowed by cross domain policy) raise SecurityExceptions
- Non-successful requests (e.g. those that returned 404s) raise WebExceptions. The WebException.Response is set to HttpStatusCode.NotFound. This is compatible with the desktop.
Font URI is Restricted to Assembly Resource
Who Is Affected: Silverlight 2 Beta1 or Beta 2 applications (not Silverlight 1.0 applications) that reference fonts (or zip of fonts) via the URI syntax in the Control.FontFamily, TextBlock.FontFamily or Glyphs.FontUri attributes and where the fonts are not embedded within the assembly (dll) of the control or application.
Fix Required
You can specify a font (or in some cases a zip of fonts) in URI format via the Control.FontFamily, TextBlock.FontFamily and the Glyphs.FontUri attributes. If you are, you will need to ensure your font is marked as a "resource" in the project system.
Browser.HtmlElementCollection replaced with by Browser.ScriptObjectCollection
Who Is Affected: Silvlierlight 2 Beta 2 applications using HTML bridge's HtmlElementCollection will break. The type has been replaced with a new type: ScriptObjectCollection.
Summary
The System.Windows.Browser.HtmlElementCollection type was changed to ScriptObjectCollection. All previous references to HtmlElement on the collection have been changed to instead reference ScriptObject. Other areas of the HTML bridge that previously used HtmlElementCollection (i.e. HtmlElement.Children) have been switched to instead return a ScriptObjectCollection. Note that if you retrieve an item from the new ScriptObjectCollection that actually is an HtmlElement, you can still cast the return value back to an HtmlElement.
The specific benefit from this change is that across all browsers you can now access both element, and non-element, DOM nodes contained in a node collection. We made this change because there is no consistent cross-browser implementation of an HtmlElement-specific collection type.
Fix Required
Change existing references to HtmlElementCollection to ScriptObjectCollection. If your existing code was working with HtmlElement return values you will need to explicitly cast the items returned from a ScriptObjectCollection to an HtmlElement. Since the collection type is now ScriptObjectCollection it is likely that on different browsers the ordinality of the resulting collection will also change. Any code that was relying on fixed offsets into the collection may need to be changed to account for non-element nodes (e.g. text nodes such as whitespace, etc…) in the collection.
Beta 2
[c#]
HtmlElement myHtmlElement = someOtherHtmlElement.Children[5];

Release
[c#]
HtmlElement myHtmlElement = (HtmlElement)someOtherHtmlElement.Children[5]; //assuming the desired element is still at offset 5

Exceptions When Changing Some Properties on an Active Animation
Who Is Affected: Silverlight 1.0 and 2.0 applications that change properties on active animations.
Summary
When you change one of the properties listed below on an active Storyboard, an exception is raised at runtime with this message: "Operation is not valid on an active Animation or Storyboard. Root Storyboard must be stopped first."
The list of properties that cannot be modified on an active animation or Storyboard are listed below:
Attached Properties
Storyboard.TargetNameProperty
Storyboard.TargetPropertyProperty

Properties on derived classes from Timeline of a collection type
Storyboard.Children (you cannot add/remove animations from an active storyboard)
ColorAnimationUsingKeyFrames.KeyFrames
DoubleAnimationUsingKeyFrames.KeyFrames
PointAnimationUsingKeyFrames.KeyFrames
ObjectAnimationUsingKeyFrames.KeyFrames

Make sure you stop the Storyboard before changing one of these properties. You can do this by using the Storyboard.Stop method.
System.Windows.Controls.Extended.dll renamed to System.Windows.Controls.dll
Who Is Affected: Anyone who uses the extended controls (Calendar, DatePicker, TabControl and GridSplitter).
Fix Required
Change all references from System.Controls.Extended to System.Windows.Controls and recompile your application.
VisualStateManager Changes
Who Is Affected: Silverlight 2 applications that use VisualStateManager.
Summary
VisualTransition.Duration has changed to VisualTransition.GeneratedDuration. This value will now only affect the generated transitions, and not the VisualTransition.Storyboard.
Example:
In the below XAML, the VSM generated animations for the Pressed-> Normal transition will be created with 1 second durations. The explicit transition Storyboard with its blue ColorAnimation will still be 2 seconds.
[xaml]
<vsm:VisualStateGroup x:Name="CommonStateGroup">
...
<vsm:VisualStateGroup.Transitions>
...
<vsm:VisualTransition From="Pressed" To="Normal" GeneratedDuration="0:0:1">
<Storyboard>
<ColorAnimation Storyboard.TargetName="MainRect" Duration="0:0:2"
Storyboard.TargetProperty="Fill" SpeedRatio="2" To="Blue"/>
</Storyboard>
</vsm:VisualTransition>
</vsm:VisualStateGroup.Transitions>
</vsm:VisualStateGroup>
VisualStateManager.CustomVisualStateManager should be set on the root visual of the ControlTemplate or UserControl, not the Control/UserControl itself. In the example below, the custom visual state manager is set on the Grid, the ControlTemplate's root visual.
[xaml]
<ControlTemplate TargetType="local:CheckBox">
<Grid x:Name="RootElement" HorizontalAlignment="Center"
VerticalAlignment="Center" Background="Transparent">
<vsm:VisualStateManager.CustomVisualStateManager>
<local:MyVisualStateManager>
</vsm:VisualStateManager.CustomVisualStateManager>
...
</Grid>
</ControlTemplate>
KeyDown Sent Synchronously
Who Is Affected: If you previously have been doing operations in the KeyDown event that could cause reentrancy into the Silverlight control, such as calling into the HtmlPage.Window.Alert function, this will no longer be supported.
Summary
We switched over our keyboard handling for character input to use the concept of the WM_CHAR windows message. This is used for TextBox/PasswordBox text entry to enable scenarios such as entering AltGr keystrokes. In order for us to do this, the KeyDown event had to be sent synchronously for managed code.
MeasureOverride/ArrangeOverride on Canvas Now Sealed
Who Is Affected: Silverlight 2 Beta 2 Applications that use MeasureOverride and ArrangeOverride on Canvas.
Summary
MeasureOverride and ArrangeOverride virtual methods on Canvas are sealed. These methods were already sealed for Grid and StackPanel. Any custom panel that requires its own layout logic should subclass Panel.
UriTypeConverter moved to System.dll
Who Is Affected: Silverlight 2 managed code referencing the UriTypeConverter class.
Fix Required
UriTypeConverter was moved from System.Windows.Controls.dll to System.dll where it resides on the desktop framework. Applications that reference it just need to be recompiled.
HtmlPage.UnregisterScriptableObject Removed
Who Is Affected: Those using HtmlPage.UnregisterScriptableObject.
Fix Required
Alternative to using HtmlPage.UnregisterScriptableObject, developers can now re-use the same script registration key for RegisterScriptableObject. This allows developers to change the underlying managed object associated with a scriptable entry point.
RenderingEventArgs Changes
Who Is Affected: Silverlight 2 managed code referencing the RenderingEventArgs class.
Summary
The following changes have been made to class RenderingEventArgs
RenderingEventArgs is moved from System.Windows to System.Windows.Media
RenderingEventArgs.ctor() is now internal
System.Windows.RenderingEventHandler has been removed.

ContentPresenter and ContentControl Changes
Who Is Affected: Silverlight 2 managed code that uses either the ContentPresenter or ContentControl classes.
Summary
The following properties were removed from ContentPresenter and ContentControl.
TextAlignment
TextDecorations
TextWrapping

Removal of FileDialogFileInfo Type and OpenFileDialog.SelectedFile(s) Properties
Who Is Affected: Silverlight 2 applications which use the OpenFileDialog.
Summary
The System.Windows.FileDialogFileInfo type is being removed. Its functionality is now being exposed via its base System.IO.FileInfo type to transparent code within Silverlight's sandbox.
System.Windows.Controls.OpenFileDialog has a couple properties which consume and expose FileDialogFileInfo. They were modified to return the FileInfo type.
In addition, the property names SelectedFile and SelectedFiles were also changed to File and Files.
Fix Required
Beta 2
[c#]
// Returns a File object for the selected file. If multiple files are selected, returns the first selected file
public FileDialogFileInfo SelectedFile { get; }
// Returns a collection of File objects for the selected files
public IEnumerable<FileDialogFileInfo> SelectedFiles { get; }
Release
[c#]
// Returns a File object for the selected file. If multiple files are
// selected, returns the first selected file
public FileInfo File { get; }
// Returns a collection of File objects for the selected files
public IEnumerable<FileInfo> Files { get; }
Sample usage of OpenFileDialog with this change:
[c#]
openFileDialog = new System.Windows.Controls.OpenFileDialog();
openFileDialog.Multiselect = false;
openFileDialog.Filter = "Text Files (*.txt)|*.txt|All files (*.*)|*.*";
bool? retval = ofd.ShowDialog();
if (retval != null && retval == true) {

// Get the filename
string filename = openFileDialog.File.Name;
// Open the file
System.IO.Stream filestream = openFileDialog.File.OpenRead();
// Do something with the filestream
// Close it
}
Removal of FullAccess Option on the ExternalCallersFromCrossDomain attribute in the Silverlight 2 application manifest
Who Is Affected: Only Silverlight 2 applications that use this combination of features:
XAP deployed on a different domain than the host HTML page, and
with application manifest (AppManifest.xaml) specifying ExternalCallersFromCrossDomain="FullAccess" on the root element are affected.

Summary
The ability for arbitrary scripts to walk the element tree, register for and get notified on events, and use the Silverlight 1.0 Downloader from script has been curtailed in a cross-domain app deployment scenario. The application manifest previously supported the ability for app author to designate the ExternalCallersFromCrossDomain attribute with the values NoAccess (default in cross-domain), ScriptableOnly and FullAccess. Support for the FullAccess option has been removed.
Many of the purposes you would have relied on the FullAccess option can now be fulfilled via the Scriptable object feature, with minor additional work on your part.
KeyFrameCollection Changes
Summary and Fix

Virtual methods Add, Contains, Indexof, Insert, Remove, get_Item, set_Item are no longer declared on the following collections:
ColorKeyFrameCollection.
DoubleKeyFrameCollection
ObjectKeyFrameCollection
PointKeyFrameCollection
PointKeyFrameCollection
StrokeCollection

Request stream must be closed before calling HttpWebRequest.BeginGetResponse()
Who Is Affected: Silverlight 2 applications that use HttpWebRequest.BeginGetResponse().
Summary
You must close the request stream on an HttpWebRequest before calling BeginGetResponse(). Previously BeginGetResponse() would close an open request stream.
HtmlWindow references on Safari/Mac will no longer evaluate to true
Who Is Affected: Code that uses System.Windows.Browser.HtmlWindow and that expects two HtmlWindow references pointing at the same DOM window to evaluate to true will now return false when running on Safari 2 or Safari 3 on Mac.
Summary
For example:
Create a page with one iframe
Use the bridge to get two references to the iframe:

HtmlWindow myWin = document.GetElementById("myIframe");
HtmlWindow myWin2 = document.GetElementById("myIframe");
With the change the following comparison will now return false on Safari 2/3 Mac:

bool areEqual = (myWin == myWin2);
Address property removed from all WebClient EventArg classes
Fix Needed
If you were depending on the Address property, you can work around this breaking change in the following way:
Beta 2
[c#]
void Callback(object sender, DownloadStringCompletedEventArgs args)
{
DebugPrint(args.Address.ToString());
}

void MakeCall(Uri uri, object userState)
{
webClient.DownloadStringAsync(uri, userState);
}
Release
[c#]
class DownloadState
{
public DownloadState() {}
public Uri Address;
public object ActualUserState;
}
void Callback(object sender, DownloadStringCompletedEventArgs args)
{
DownloadState userState = (DownloadState)args.UserState;
DebugPrint(userState.Address.ToString());
}
void MakeCall(Uri uri, object userState)
{
Uri absoluteUri = uri;
if (absoluteUri.IsAbsoluteUri == false)
{
absoluteUri = new Uri(new Uri(webClient.BaseAddress), absoluteUri);
}
DownloadState downloadState = new DownloadState();
downloadState.Address = absoluteUri;
downloadState.ActualUserState = userState;
webClient.DownloadStringAsync(uri, downloadState);
}
Constructors Made Internal
Summary
You can no longer create the objects listed below because their associated constructors have been made internal:
SizeChangedEventArgs
TextChangedEventArgs
DownloadProgressEventArgs
ExceptionRoutedEventArgs
KeyEventArgs
MouseButtonEventArgs
MouseEventArgs
StartupEventArgs
Expression
GeneralTransform
Geometry
ImageSource
PathSegment
SetterBase
Transform
BindingExpressionBase
InputMethod

Exception type change for System.Xml exception type
Summary
In the methods/constructors shown below, we will no longer be checking for null arguments. As a result, the usage of null arguments will result in a NullReferenceException. In previous builds of Silverlight, use of a null argument would result in an ArgumentNullException being thrown. There is no change in functionality, just the type of exception that is being thrown.
XmlReader.IsName method
XmlReader constructor
XmlReader.MoveToAttribute method
XmlReader:IsNameToken method
XmlNamespaceManager constructor
XmlReader.Nametable.Add method
XmlReader.Nametable.Get method
XmlCharCheckingWriter.WriteQualifiedName method
XmlCharCheckingWriter.WriteDocType method
XmlConvert.ToBoolean method
XmlConvert.ToDouble method
XmlConvert.ToSingle method
XmlConvert.ToDateTime method
Cannot create classes in XAML that do not have accessible constructors
Summary
Certain classes that were defined by the Silverlight runtime were creatable in XAML, even though they did not have an accessible constructor. With this change, you can no longer instantiate those classes in XAML.
These classes (which only have internal constructors) can no longer be created in XAML:
TriggerCollection
InlineCollection
RowDefinitionCollection
ColumnDefinitionCollection
RoutedEventARgs
MouseButtonEventArgs
KeyEventARgs
ErrorEventArgs
UIElementCollection
Downloader
InternalWebRequest
MultiScaleSubImageCollection
MediaAttribute
MediaAttributeCollection
ExceptionROutedEventArgs
DownloadProgressEventArgs
StartupEventArgs
TextBoxBase
TextBoxView
TextChangedEventArgs
RuntimeHostEventArgs
SizeChangedEventArgs
RenderingEventArgs
ItemCollection
CorePropertyChangedEventArgs
IsEndabledChangedEventARgs
TypeProxy
ManagedObjectReference
AutomationPropertiesEnum
DependencyPropertyProxy

Get AG_E_UNKNOWN_ERROR in Silverlight 2 but not in Silverlight 1
Summary
In previous versions of Silverlight, when media failed because a media file was not available, a MediaFailed event was fired but if the MediaFailed event was not handled by the developer, the end user would not be notified of the failure. Now when a handler is not hooked up to the MediaFailed event, the error bubbles up to the default OnError handler of the plug-in and AG_E_UNKNOWN_ERROR is displayed to the user.
Fix Required
Attach the MediaFailed event to your MediaElement objects and handle errors as appropriate.
Platform looks for generic.xaml as a resource at themes/generic.xaml
Summary
The platform now looks for the generic.xaml resource dictionary as an assembly resource in the "themes" directory rather than the root directory.
Fix Required
Move your generic.xaml resource underneath the "themes" folder under ControlLib in Solutions Explorer in Visual Studio.
HTTP Polling Duplex OM Changes and Reengineering
Who Is Affected: This will impact anyone using the HTTP Polling Duplex channel.
Summary
PollTimeout setting on the server side (PollingDuplexHttpBinding and PollingDuplexBindingElement) has been renamed to ServerPollTimeout
PollTimeout setting on the PollingDuplexBindingElement (client side) has been renamed to ClientPollTimeout.
PollTimeout setting on the PollingDuplexHttpBinding (client side) has been cut. In most scenarios, it should not be necessary to change this. If a change is necessary, it can be achieved through the ClientPollTimeout on the PollingDuplexBindingElement.
Client-side support has been cut from the non-Silverlight (server-side) polling duplex assembly (i.e. BuildChannelFactory will throw a NotSupportedException). That is, in RTM, the client side for polling duplex must be Silverlight (and the server side must be the regular .NET Framework, but this restriction was already in place in Beta2).
Default timeouts have been changed for the Duplex channel. For most common scenarios, the new out-of-the-box defaults should be appropriate and there is no need to change them.
An error (404) on a polling request will cause the duplex channel to fault.
Various invalid messages used to be ignored by the Duplex stack but will now be rejected.
If any HTTP error (404,500,…) is encountered during a SOAP call, a CommunicationException is now thrown instead of a ProtocolException.

Breaking change to Silverlight native hosting IXcpControl COM interface
Who Is Affected: Applications that host Silverlight 2 natively via its COM APIs.
Summary
The following splash screen related properties added to IXcpControl interface are being broken out and being moved to a new IXcpControl2 interface:
get_OnSourceDownloadComplete
get_OnSourceDownloadProgressChanged
get_SplashScreenSource
put_OnSourceDownloadComplete
put_OnSourceDownloadProgressChanged
put_SplashScreenSource

In addition, the LoadRuntime function is also being moved to IXcpControl2.

Content-Type is allowed on cross domain request by default
Summary
Both supported cross domain policy files (crossdomain.xml, clientaccesspolicy.xml) no longer need to explicitly allow the Content-Type request header. The Content-Type header is always settable on POST xdomain requests, as long as the request itself is allowed by a cross domain policy file.
In addition, the LoadRuntime function is also being moved to IXcpControl2.

Fix Required
Previously you needed to specify Content-Type in the headers whitelist. Now, Content-Type is always allowed, so the bolded "Content-Type" attribute value is no longer required just for setting the Content-Type (see below).
clientaccesspolicy.xml
Old version that explicitly listed Content-Type as settable. (This file still works in SL2 RTM.)
[xaml]
<?xml version="1.0"?>
<access-policy>
<cross-domain-access>
<policy>
<allow-from http-request-headers="Content-Type, SOAPAction">
<domain uri="*"/>
</allow-from>
<grant-to>
<resource include-subpaths="true" path="/"/>
</grant-to>
</policy>
</cross-domain-access>
</access-policy>
New version that still allows Content-Type to be set
[xaml]
<?xml version="1.0"?>
<access-policy>
<cross-domain-access>
<policy>
<allow-from http-request-headers="SOAPAction">
<domain uri="*"/>
</allow-from>
<grant-to>
<resource include-subpaths="true" path="/"/>
</grant-to>
</policy>
</cross-domain-access>
</access-policy>
crossdomain.xml
Old version that explicitly listed Content-Type as settable. (This file still works in SL2 RTM.):
[xaml]
<?xml version="1.0"?>
<cross-domain-policy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.adobe.com/xml/schemas/PolicyFile.xsd">
<allow-access-from domain="* " />
<allow-http-request-headers-from domain="* " headers="Content-Type, SOAPAction" secure="true" />
</cross-domain-policy>
New version that still allows Content-Type to be set:
[xaml]
<?xml version="1.0"?>
<cross-domain-policy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.adobe.com/xml/schemas/PolicyFile.xsd">
<allow-access-from domain="* " />
<allow-http-request-headers-from domain="* " headers="SOAPAction" secure="true" />
</cross-domain-policy>
Enforcing delegate type check when two delegate objects are combined
Who Is Affected: Code that bypass the delegate type check in Delegate.Combine by calling MulticastDelegate.CombineImpl directly.
Fix Required
If you want to combine two delegate objects they should be of the exact same delegate type.
Miscellaneous API Changes
UIElement.HitTest method has moved to the VisualTreeHelper class and renamed to VisualTreeHelper.FindElementsInHostCoordinates.
Moved DependencyPropertyChangedEventHandler delegate type from System.Windows.Controls to System.Windows namespace.
Control.IsTabStop defaults to true. Now, all Control derived classes (directly or indirectly) have IsTabStop set to true except, UserControl, HyperlinkButton, ScrollViewer and ListBox.
WebHeaderCollection.Keys property was replaced with the AllKeys property.
WebHeaderCollection.Headers property was renamed to Keys.
WebRequest.RegisterPrefix() now returns false in failure cases per the interface contract from the desktop framework rather than throwing an exception.
WebResponse.Dispose(bool explicitDisposing) was removed.
Deployment.PartProperty is now read only.
Deployment.EntryPointAssemblyProperty is now read only.
Deployment.EntryPointTypeProperty is now read only.
Deployment.RuntimeVersionProperty is now read only.
Deployment.ExternalCallersFromCrossDomainProperty is now read only.
Thumb.IsDragging is now read only.
Slider.IsFocused is now read only.
ButtonBase.IsFocused is now read only.
ButtonBase.IsMouseOver is now read only.
ButtonBase.IsPressed is now read only.
ToolTipService.GetToolTip is now private.
IRawElementProviderSimple is now sealed and has a private default constructor.
Setter.PropertyProperty is now internal. Please use the CLR property instead of the DependencyProperty.
Slider.UpdateTrackLayout() is now internal.
Slider.OnOrientationChanged() is now internal.
Slider.OnIsFocusChanged(DependencyPropertyChangedEventArgs e) is now internal.
ComboBox.get_IsSelectionActive() is now internal.
ComboBox.ScrollIntoView(Int32 index) is now internal.
ComboBox.get_SelectionBoxItemTemplate() now returns System.Windows.DataTemplate.
PasswordBox.SelectionChanged is now private.
MouseEventArgs.Handled was moved to MouseButtonEventArgs.
RenderTargetBitmap was renamed to HostingRenderTargetBitmap and moved from System.Windows.Media.Imaging to namespace System.Windows.Interop.
AutomationPeer constructor is now protected.
TriggerActionCollection.Item now takes System.Windows.TriggerAction instead of System.Windows.Media.Animation.BeginStoryboard.
TriggerCollection.Item now takes System.Windows.TriggerBase instead of System.Windows.EventTrigger.
RoutedEventArgs.Source was renamed to OriginalSource and is now read-only.
ITableItemProvider and ITableProvider are now derived from IGridItemProvider and IGridProvider.
The KeyboardNavigation class is now internal.
ColumnDefinitionCollection constructor was made internal.
InlineCollection constructor was made internal.
ItemCollection constructor was made internal.
RowDefinitionCollection constructor was made internal.
UIElementCollection constructor was made internal.
TriggerCollection constructor was made internal.
Listbox field ListBoxItem._itemsControl is now internal.
Ink.Stroke constructor changed to ctor(System.Windows.Input.StylusPointCollection).
CanConvertFrom(Type sourceType) changed its signature to CanConvertFrom(ITypeDescriptorContext context, Type sourceType).
CanConvertTo(Type destinationType) changed its signature to CanConvertTo(ITypeDescriptorContext context, Type destinationType).
ConvertFrom(object value) changed its signature to ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value).
ConvertFromString(string text) now is ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) where value of type string.
ConvertTo(object value, Type destinationType) changed its signature to ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType).
ConvertToString(object value) now is ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) with destinationType of type string.
ItemCollection constructor is no longer available so any code that tries to instantiate an ItemCollection directly will no longer compile. This class is supposed to be instantiated only within ItemsControl.
ContentPresenter now derives from FrameworkElement instead of Control.
Control.OnIsEnabledChanged was removed. Now use IsEnabledChanged for extended controls.
DownloadProgressEventHandler was removed.
The following converters were removed:
- TextDecorationCollectionConverter
- FontStretchConverter
- FontStyleConverter
- FontWeightConverter
- FontFamilyConverter

Google Chrome for the Enterprise?

2008-09-02T20:28:00.007-04:00

Google's Chrome is an impressive little beta. Performant? Check... Slick? You bet... More intelligence packed into navigation? Yup... Developer tools baked in? As warm as apple pie...

But does Google Chrome have an Enterprise twinkle in its eye?

A few things to be excited about:

javascript running in a VM
As the Google Chrome Comic Book states running JS within a VM allows the browser to optimize javascript and actually compile the structure into machine code so that "interpreted" code is not over-interpreted. Chrome is supposed to be fast. And this should make Knowledge Workers with 40+ tabs, happy.
process-level isolation
Process per tab, process per site. every app, be it web app or a component of Chrome runs as it's own application. Many benefits to this, e.g. crashes are limited to impacted process/tab, resources are allocated to active tab not the entire browser, jail-like security per process, and so on. This design boosts overall stability of the browser.
developer tools baked in
Beginnings of a superb JavaScript debugger and analyzer. Dom element highlighting, in-line style info, style metrics and element properties. And the niftiest addition: web-page performance analytics with charts. I'm sure someone will do a punch-for-punch againt Firefox's FireBug extension.
wrench->options->under the hood->change proxy settings
Looks like Connection Settings are delegated to Internet Explorer's - now that's interesting. This means that Group Policies that govern IE's settings can also apply to Google Chrome. I wonder what else can be managed...
about:memory
Measures memory usage of this multi-threaded browser
about:plugins
There is an about:plugins page that shows loaded plugins. Looks exactly like Firefox's

Things to look forward to:

Extensions
RSS support
Spell checker
...and so on...

As for Enterprise-friendliness. Much of our ability to adopt Google Chrome in the enterprise will depend on granular Settings Management for Browser and Gears via a MissionControl-like mechanism or GPO. Enforceable and customizeable Security Zones will permit richer interoperability with the Desktop. Perhaps the extension system will facilitate this with ease. But of couse, this is tbd.

What is Google going after? As a colleague put it, the web browser is the unsung hero of the desktop. It is perhaps the most important application there. But it is not just a gateway to the net. The web browser is an application container in it's own right. The gap between desktop and web apps is quickly shrinking. Gears are not simply an offline mode but perhaps the bridge to interoperability between the web browser and other desktop-bound components. Perhaps we'll see these concepts in play on our mobile devices sooner than on our desktops. Perhaps Google is really after an ad revenue-powered "virtual" desktop for the consumer, reminiscent of what Citrix is trying to do for the enterprise?

As for Enterprise-wide deployment of Google Chrome, we'll have to look at its about:config equivalent first!

NYBI Meetup #3 Recap

2008-05-14T23:01:00.001-04:00

The Recap
The third Meetup was fully dedicated to discussion. It was driven by a few PowerPoint slides from one NYBI member's presentation given at the CTO Summit in Summer of 2007.

One slide of interest was about a proposed BI Ontology reproduced, in part, below:

BI Ontology

Decision Space

Decision Purpose

Decision Frequency

Decision Impact

Tool Space

Data
Models
Experience
Feedback

There was another level of detail for each sub-bullet that will become available when I post the original slides. Ontologies are important because they provide a shared and common understanding of concepts presented and discussed in forum. The same way that we hope to derive consensus on Trends and Truths within the BI space, so do we hope to establish a descriptive (and shared) language about BI with the aid of the proposed Ontology.

An introductory slide or two spoke to the "State of Affairs" as well the "This is how we came to be here" and spurred on 2 full hours of discussion.

Some highlights:

Most organizations looking to introduce BI into their fold succeed in rolling out a Data Warehouse. Rolling out Reporting infrastructure is the difficult part. If the organization is lucky enough to succeed, this reporting infrastructure tends to be the most expensive investment.
The industry itself evolved from ad-hoc tools to very structured tools and mechanisms. Approach to successful BI implementation became a Trade and a science in of itself.
The BI Ecosystem is very large. There are a few established Tools and Tool Vendors but community of people that provide quality or reporting services is for these Tools is significantly larger.
Vendor tools, however, are going through mergers and the Vendors are losing independence. Will a community emerge to not just support the Vendors but to actually drive innovation in the space and offset the aforementioned loss of independence by Vendors?
Paper distribution has been consistently declining over the last 4 years to be replaced by digital systems. Are paper statements in existence today exercises in Data Summarization? Why are our banking statements and our bills still so confusing and uninformative?
In turn, with an encroaching demand from end-users to be able to do real-time analytics and trending of their own personal data, why are banks so slow to spice up their online banking systems? Are new sites like Mint.com and QuickenOnline setting a new standard in personal finance analytics?
How much longer will we wait for the higher activities of analysis? Is the next step in BI Tools that aid in decision making process rather than just visualization? Can "actions" exposed by these new BI Tools be contextually relevant and drive specific end-results, such as yield competitive advantage?
Volume of data is now manageable. Tools that are making sense of this volume are driving innovation.
Is the notion of Business Intelligence simply too constrained to fully encompass possibilities? Are we transitioning to a more general-purpose, behavioral, Collective Intelligence that enables an organization to tap into data previously unaccessible or simply discarded? Can this aid an organization's process of innovation and feed competitive advantage?
Is it possible to phase out manual Knowledge Management along with paper distribution and plugin in systems that interpret data on a Semantic level?
Are Personalization of Services and Individual Privacy on opposing sides? Are the notions of privacy on the Internet and a Corporate Intranet so drastic that most innovation in Collective Intelligence will, in fact, occur on the Intranet where Individual Privacy is a more manageable Can of Worms?

Truths and Trends

Truth: There are lots more data sources of interest than what is currently accessible on the internet
Truth: Improving on what computers tend to do well does not necessarily result in value to the end-user
Truth: Audio processing is more difficult than Video processing
Trend: Use of Voice and Video as datasources is a new frontier. We wonder how much of it is native analysis vs metadata processing.
Trend: More real-time decision-making at the hands of the user.
Trend: Enterprise environment will give way to enterprise community.
Trend: Web2.0 Collaborative tools are becoming more accepted in the enterprise as both the enterprises and the vendors mature
Truth: There are lots more data sources of interest than what is currently accessible on the internet
Truth: Improving on what computers tend to do well does not necessarily result in value to the end-user
Truth: Audio processing is more difficult than Video processing
Trend: Use of Voice and Video as datasources is a new frontier. We wonder how much of it is native analysis vs metadata processing
Trend: More real-time decision-making at the hands of the user.

Next Meetup
SAP Business Objects folks will be joining us to help us explore Xcelsius, their new analytics tool. They will also speak to the rest of the near-future product road-map. Details are available on the http://nybimeetup.org site.

Intro to Enterprise RSS

2008-05-01T20:18:00.010-04:00

Firstly, what is RSS and how does it relate to what is familiar to the "Enterprise" us?
In of itself RSS is nothing special. It is just a format for "Latest Headlines". Roughly it says that Content A is about something and the full posting of the same is located at http://A. Content B is about something else and lives at http://B. Where-as prior to popularization of "syndication" the user had to go to sites of interest to peruse updated content, RSS now allows content producers to simply "push" updates to us as we busy ourselves with more important tasks.

Value in RSS is introduced by the Publisher who takes ownership of publishing the latest headlines in a known or easily discoverable location that does not change while keeping that list of headlines up to date. Value is passed on to the Consumer through software that knows how to deliver fresh content to you, the Knowledge Worker.

A Use Case
Let's say a Team wants to maintain a high-level, chronological log of project activity and make this log available for others to peruse at individual convenience (buzzwords: asynchronous consumption of syndicated content). A classical way of disseminating this information (in the past) has been to spend man-hours designing these headlines into a Newsletter format and to send the Newsletter out to everyone via email. Those who care and those who don't care would receive this email aka spam.

Now let's say this Team hosts an RSS file that is auto-magically updated on a daily basis by some publishing system that you, the user, should not really know or care about. Let's say it's Sharepoint (since Sharepoint 2007 does this very well...). The system is pre-configured in such a manner so that whenever a member of the Team publishes an article via Sharepoint, the RSS file representing all such articles published is automatically updated with the latest headlines on published documents.

Those interested in latest headlines from that group can direct their RSS Client to keep an "eye" on that Feed. Specifically, your client "pulls" the latest content on an interval, directly from the "source" without involving Newsletters and without spamming your Inbox with content of suspect relevance to you.

Two important terms here are: RSS Feed - that which is owned and updated by the content owner, and RSS Reader (or RSS Client) through which the end-user maintains subscriptions of interest and by which the end-user can always see the "latest" headlines coming from the Content Owner.

For further details on what RSS is and is not, please take a look at the Wikipedia entry on RSS.

Why are we even bothering with "centralized" or "IT"-driven RSS?
Let's take a very practical (and conservative), risk-minded perspective on infrastructure common to most Fortune 500 enterprise-size companies. Assumption here is that RSS Clients of all sorts run rampant in the environment's Intranet and RSS content is treated as any other web content. This means that all outbound requests for web-hosted content on the "out there" internet as well as the content retrieved from the web go through a Proxy tier commonly maintained by some division of Corporate IT.

Imagine everyone (that's us, to be referred to as "we") in this hypothetical Firm maintaining a list of 50-100 subscriptions to external and internal sources of content. Let's also say that because we always subscribe to Content of Interest and therefore content of Relevance, we wish our RSS Clients to "keep an eye" on each feed and to pull interesting updates to our subscriptions every 30 minutes.

In reality, what this means is that everyone in the Firm is asking the CNN's of the world for updates on ALL headlines of interest every 30 minutes.

A sidebar on Proxies and their role within our environment is important here. We know that we access the "outside" internet through Proxies. Why Proxies? Proxies do some security things. More importantly, Proxies do some content caching and networking and load optimization that are essential to maintaining healthy connectivity to the internal and external networks. Proxies are critical components of an enterprise's infrastructure and are, essentially, Gateway Keepers to the Web. Most Proxy infrastructures are probably designed to accommodate Humans perusing sites. Systems that do demand a high load of network content are usually provisioned, accounted for, and paid for separately as a specific requirement. The Business Unit requiring such special capacity will usually take on this cost. Recall in our original assumption that no such "special" considerations were in place for RSS traffic.

Your RSS Client asking for updates from the web is equivalent to your Computer perusing sites. Your Computer can do a lot of things quickly, such as pull 50-100 subscription updates within a matter of seconds: something that would take us much more time to do by hand. What does this mean? It means that the amount of traffic to and from the outside Internet increases drastically. This happens because polling of many CNNs is condensed to a short amount of time. This happens per individual with RSS feeds over the course of the day. In other words, unrestrained RSS Clients Gone Wild in our environment will create too much unplanned traffic through the Network and will overload the Proxy servers not provisioned to handle such load. Risk here is disrupting daily routing and more importantly business critical applications relying on the network. Enterprises should deem this as an unacceptable risk. Does this mean RSS should not be allowed in the environment? Absolutely not!

Solution
As mentioned before, Proxies do some caching. For example, when you browse for CNN.com homepage and I browse for CNN.com homepage the Proxy is smart enough to realize that CNN.com is not a unique resource and that more than one person wants to and will probably want to see the same content. Rather than using up Networking resources to deliver content to you from CNN.com directly, Proxies will simply cache that page locally and serve out the local (cached) copy to the user for subsequent requests. This is economical.

The exact same model needs to apply for all RSS traffic in and out of our environment. Something needs to sit between your RSS Client and the RSS Feed Owner to provide exactly the same type of mediation and optimization.

To enable RSS within the Firm, the Firm must deploy some RSS-specific Proxy-like infrastructure to Gatekeep RSS traffic. IT should own this task.

Now that RSS is going through a centralized "hub", what else can we do with it?
When data is managed in a centralized location, all sorts of interesting analytics, and intelligence-driven applications can come into play. For example, subscription data, read/unread status information in of itself can yield rough ranking of popularity. Tagging of content can yield human-driven meta information that democratizes categorization of content coming in from a very large and daunting repository: the web. Popularity ranking and democratized categorization yields personalized, intelligent recommendations and filtering. All these buzz words imply boost to productivity by way of highlighting information we "know" is relevant to us and by way of not spamming us with content that is not.

This subscription-based content-delivery mechanism, when coupled with such intelligence, is a valuable paradigm in an environment plagued with info-glut, tight deadlines, and the ever-present abuse of emails. How many mailgroups do you belong to?

Why not simply invest in more Proxies?

General-purpose proxy servers commonly purchased are extremely expensive - can cost as much as $80,000 per box
Proxies are not specialized to provide the bells and whistles mentioned in the previous section and therefore under-represent the value of syndication within an Enterprise environment

Taking it a step further
Let's imagine that we have this piece of infrastructure sitting in-house, that allows us to aggregate, categorize, rank and disseminate content not only intelligently but also via a standardized and globally-acceptable content format: RSS (XML). When the Firm federates this system with already-existing and already invested-in internal Collaborative Platforms, syndicated, relevant content does not have to originate from traditional "news" sources alone. In fact, such syndication can expose internally generated data of all sorts. Think improved portal adoption through Dashboarding, Agile Project Management and Knowledge Bases, system status notifications and so on. For specific ideas on how to leverage Blogging and syndication for Agile Product Management and Knowledge Bases, take a look at my Blog's series called "Taking Baby Steps".

Taking it one more step further
RSS in the Enterprise can drive Social discovery of peer-recommended and peer-generated content by virtue of mining this centralized repository of content and subscriptions. Cleverly federated with Collaborative systems like Sharepoint, the Enterprise RSS Server can socialize boring document repositories and lists in Sharepoint. Imagine "following" content generated, reviewed and starred by the head of your department. Newsfeeds of social activity made popular by Facebook can be easily constructed by marrying Enterprise RSS infrastructure with Collaborative infrastructure such as Sharepoint. And this is only the beginning... For example, semantic analysis of subscriptions and consumed content can yield better understanding of relevancy and quality of recommendations as well as intelligent filters and subscriptions.

Conclusion
Centralized, enterprise-class RSS infrastructure is an enabler of more than news consumption. Social, asynchronous feedback loops are critical aspects of collaboration and are made possible by investing in RSS as infrastructure.

Vendors such as NewsGator, Attensa, and KnowNow are currently leading the market in providing the Enterprise with a "Buy not Build" option for exactly such infrastructure. Who of these "gets" Enterprise requirements best? I urge you to compare their respective offerings against specs outlined in my Blog Post entitled "Why Vendors Don't Get Enterprise2.0". I have. Not surprisingly, when compared against core requirements and the extra credit, as outlined above, competition among the three is not as close as analysts and the laggers of the three would like you to believe...

NYBI Meetup #2 Recap

2008-04-02T01:09:00.009-04:00

The Recap
The second NYBI Meetup took place in a spacious board room of 1633 Broadway. The meeting kicked off with an exploration of QlikTech's in-memory analytics platform called QlikView with Scott Taylor and Nik Boman. QlikView is seeing success in the financial sector in NY and we wanted to know what made QlikView tick, what made it great, and how the "wisdom" of the NYBI crowd could make it even better. The PPT presentation of QlikView is available from the NYBIMeetup.org's File download section here.

From my recollections and sparse notes
QlikView is a visualization and analysis tool.

QlikView allows a Super User to correlate data sets from various data sources (local or remote) and to store a highly compressed (loaded data is 15% on avg of original data size) snapshot of the relational data map into memory. Coupled with a file structure that permits O(1) access to data and linear, O(n) traversal of data sets, this in-memory storage essentially serves as a Virtual Cube of correlated data for the user to play with. A very rich interface that is available in client, or embedded form, permits almost serendipitous creation of dashboards with parametric drilling, intelligent filtering - the works. Controls adjust themselves and each other instantaneously - the Regular User interacts with the charts through intuitive click and drag motions. The assumption is that the data loaded into QlikView is already of high quality/integrity.When asked "Who is typically the first person among client prospects to go 'Oooh! Aaaah!", response from the QlikTech guys was "Deprived end-users that have to go to IT for cube build-outs that may take months to generate 'ooh and aah'. IT that sanctions ownership supervises, scrutinizes, realizes that QlikView is a boon to them."

Challenges to QlikTech and points of Discussion

Is not the goal of BI, actionable outputs? Hypothetically, with QlikView I found my 3 bad products and I want to commit the pricing strategy - I have to write something out/communicate - If I want to do that, I have to interact with other modules (beyond BI modules) to make actions, how do you make the action happen? Should the products not better integrate into popular desktop productivity apps? For example, how can my interaction with these dashboard be affected if I could key off of an email address to view a Sales Report for that person in a sidebar within Outlook? (reference to Xobni). As a platform, QlikView has potential for such rich integration - the exercise is left for IT or QlikTech's affiliates.
What kind of API should BI platforms expose? What do we really wish to do on the Desktop vs on the Server?
What about community contributions? A community of business partners and affiliates who align to complete a vertical is not necessarily the same things as, let's say, a community of developers writing and contributing extensions to enhance a product's core (i.e. Firefox community and extensions development). Is there value for BI vendors to stretch beyond affiliate networks in order to establish an open participation and innovation culture? With respect to NYBI Meetup, what would something like that look like?

Truths and Trends
Following above rhetoric, in turn, should not NYBI Meetup be about actionable outputs? After all, a Community has to deliver value to those it serves. One baby step forward was to conclude the meetup with "Can we derive any Truths or Trends about BI from topics covered in discussion?" Here is what we came up with:

Truth: People are looking for a better way to solve the same problems. Core Issues of BI are still prevalent. Recent advances in BI tech now provide better ways to deal with these Issues. QlikView is a note-worthy example of such innovation in the space.
In-memory processing is Trend.
RIA (AJAX) adoption and movement to web interfaces is a Trend.
Truth: Data Quality is a Foundation for BI
Truth: BI Tools need to consume WebServices as a datasource
Truth: Killer App = functionality + price

Next NYBI Meetup is at end of April
We are always looking for interesting presentations. To sign up, please visit http://nybimeetup.org.

FreeMind Flash Browser Google Gadget

2008-03-25T00:40:00.007-04:00

I finally got around to writing a Google Gadget while exploring what a bit of XML and JavaScript can do for Google Sites.

For starters, I decided to bake the FreeMind Flash Browser into a gadget. You can now embed your FreeMind-generated MindMaps into a Google Gadget with my FreeMind Flash Browser Google Gadget. Feedback is welcome - hope you find it useful.

One caveat/limitation. Flash security policy will prevent crossdomain loading of your MindMap. Specifically, the gadget code is hosted on a *.gmodules.com domain. However, most users will wish to upload/embed MindMaps to their Google Sites (sites.google.com) or another Google domain. At the moment, this will not work as Google does not host a Crossdomain Policy file at its root. It is this policy file that allows Flash to load movies across Google's domains. I've posted an inquiry on the Google Sites Help Group to see if there is any traction towards enabling such a policy.

For now, what works for me is:

Upload the MindMap to a hosting account you have control over.

Create a crossdomain.xml policy file:

<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy
SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
<allow-access-from domain="*.google.com" />
<allow-access-from domain="*.gmodules.com" />
<allow-access-from domain="*.googlecode.com" />
</cross-domain-policy>

Upload the file to the root location of the domain under which your MindMaps are hosted, i.e. http://mydomain.com/crossdomain.xml

Specify the fully qualified url to the MindMap within the FreeMind Flash Browser Google Gadget initLoadFile setting, i.e. http://mydomain.com/mymaps/mindmap.mm. The gadget should be able to render the map.

Phun - 2D physics sandbox

2008-03-09T15:24:00.001-04:00

Good ol' NYTech meetup. A member just sent out a link to http://www.phun.at - a 2D physics sandbox. Kids, let your imagination run wild!

Phun videos on YouTube: http://www.youtube.com/groups_videos?name=phun

NYBI Meetup #1 Recap

2008-02-27T19:29:00.008-05:00

The Recap
The first New York Business Intelligence Meetup ran about 40 minutes over its 90-minute allocation. Membership grew from 3 to 26 members in under two weeks. Ron Moore played host, in a cozy, makeshift conference room, to 11 members (12 total). I was the only person constantly looking at the clock - but that came with the job description.

Agenda was "oatmeal" - basic ingredients congealing into something healthy and edible by a diverse group of specialists and enthusiasts, all feeling out NYBI Meetup's stomping ground. Introductions and individual identification with the BI space were in order. There seemed to be an even distribution of hard-core practitioners of BI, entrepreneurs looking to carve out a niche, enthusiasts (like myself) looking for a clue, instructors, and technologists struggling with the "what should I" and "how should I" aspects of the field.

This naturally lent itself to a prolonged deliberation on various topics. From philosophy to best practices and usability, the group was etching out boundaries and establishing interest camps. For a taste, some thoughts floating around covered:

Who's job is it to define Vision for BI within an organization? What role do Technologists play?
How does one go from a home-brewed analytics engine with Excel as the interface to a sustainable, cost-friendly vendor solution?
What do end-users want out of BI? Do they even know?
What are some common applications of BI? What are the new, creative applications that are enabled by recent trends in how people and systems exchange information?
What is the balance between need-based drivers and "cool" technology-based drivers?
Who's job is it to create awareness and to sell?
Why is the Microsoft stack more attractive than other stacks? What is the criteria?
What is the BI Pyramid and what is it's Tip?
Why is data integrity so darn difficult?
Can Open Source solutions compete?

Some entertaining, but paraphrased, sound bites:

Technologists tend to lead innovation within BI because they can build "It". However, technologists also build a lot of "S. H. It".
If the computer looked like a frying pan maybe my grandma would be more willing to use it. Shouldn't the same hold true for BI visualization tools?
So, you could trade 2 Julia Roberts for 1 Richard Gere? -- In reference to a startup in Russia that created a data-mining driven "forex" market where people trade the perceived value of a celebrity

Ron passed up his presentation on Essbase for these discussions to continue. We did however, get to see a brief intro to Microsoft's Performance Point Server from Victor Shamanovsky.

For a wrap up, I wanted to set a clearer trajectory for the Meetup and to focus conversations towards more tangible/practical means. Consensus appears to be: 50% Process/50% Technology. Philosophy, high-level discussion akin to what's highlighted above would fall into the former category. Product demos and real hands on BI technologies for the latter one. Essbase and PPS presentations will roll over to the next event.

My take...
Achieving topical focus for a diverse group of interests and experiences is quite challenging. Discussion should most likely pivot (horrible pun intended) on:

Business sectors and verticals. Past, current, future role of BI. Practical applications, best practices, room for innovation, market leaders, vendors, entrepreneurs etc.
The discipline itself. Warehousing, ETL, working with structured/unstructured data, core technologies, architecture, data design and integrity, reporting, UI.

Perhaps each get-together should recognize a focal point for the Process portion, ie, Profitability modeling in Finance or Sentiment Analysis and Tonality. The Technology section should then dive into available solutions, innovation, and best practices within the realm of the topics discussed in the Process portion.

Where can this take us?

A high-caliber Meetup around BI can obviously provide a business networking forum for industry professionals. Strengthening NYBI's reputation and brand will attract high caliber sponsors, vendors, and professionals. I would love for employers to look to the meetup for capable talent pool, for entrepreneurs to find collaborators, and so on.
Can this meetup influence the trajectory of innovation within BI? Will vendors and entrepreneurs be interested in vetting new products and ideas through the meetup? Can we do more than discuss and look at demos and actually deliver our musings, evaluations and conclusions to the vendors themselves? In turn, can we build a reputation and level of trust for all of this to become a reality??

I submit the above as evidence of a budding Meetup. I leave it to the members to keep my optimism grounded. Thanks to everyone who could make it. To those who couldn't, hope to see you next time! Special thanks to Alon P, my buddy and co-organizer of the Meetup and to Ron Moore for hosting.

To sign up, please visit the NYBI Meetup Homepage. There will be a healthy amount of activity through the businessintell-2@meetup.com mail-list as we build and prepare for our next event in March.

New York Business Intelligence First Meetup!

2008-02-23T20:55:00.006-05:00

In my musings on the next-generation enterprise, I keep coming back to the position that any social and contextual insights gleamed from provisioning new collaborative working models must influence an organization's business intelligence systems. This is not limited to rich interfaces and better interactivity. In fact, collaborative revolutions within the Enterprise will both feed and consume information from internally facing BI systems - the true neural network for an enterprise's brain.

I also recognize that my understanding of BI is rather rudimentary and lacks the perspective to truly participate in innovation within this field. And so, the New York Business Intelligence Meetup is born.

Click here to check out
The New York Business Intelligence Meetup!

First meetup is Tuesday, February 23rd at 7pm and is sponsored by Ron Moore, Founder and President of Marketing Technologies Group, an Essbase consulting and training firm. Ron has also, graciously offered his office space for the event, conveniently located in the Financial District, 55 Broad St. 10th Floor.

For more details, please visit the Event Page.

Customizing Firefox's Reporter for the Enterprise

2008-02-06T10:29:00.000-05:00

Objective

This post will provide a step-through for customizing Mozilla Firefox's Reporter Extension. Goal is to rewire publishing functionality so that submissions via Help->Report Broken Web Site... can be directed to the Enterprise's internal repository rather than Mozilla's. Caveat: modifications have been tested and are in production for deployments of Firefox 2.

Motivation

Early in the adoption process, not every site/webapp on the Intranet will be Firefox-friendly. A balanced view of "low hanging fruit" is required to prioritize remediation.
Reporting will help you identify applications causing the most "pain" to end-users. Every submission of a URL is essentially a Vote. Parlaying popularity with business criticality of the application itself will aid the remediation teams in scheduling work that takes into account, both, the needs of community members and your institution.
In short, creating transparency for what could be a tedious process along with active engagement of your community of users is

a crowd pleaser
will allow you to avoid lonesome hours of investigating and cataloging broken apps
will enable you to leverage your community for all phases of the remediation process, from discovery to testing

"Wall of Shame" Dashboard
Where should these results be published? The ideal data structure is a basic list. The important columns are already provided by "vanilla" Reporter:

Web site URL
Problem Type
Describe Problem
Email -> For the Enterprise, this Optional field is changed to Required, is locked and is auto-populated with the user's domain UID, basically whatever is used to log on to the work environment and is set to the Environment's %USERNAME% variable.

Whether you decide to build your own database with a frontend + REST/SOAP interface or simply leverage something like Sharepoint, where list-based reporting of this exact nature is the bread and butter of the platform, a few things are recommended:

Make your data Public - allow anyone in the Firm to view the list of "broken" websites. Depending on your company's culture, you may even wish to induce a meme to the effect of "not supporting Firefox is shameful...". My preference is to title the Dashboard "Wall of Shame".
Group entries by "Product" not by "URL". Since all you are getting from the report is a potentially long URL, without getting too fancy, you may wish to simply truncate it at the top directory level. At this point, grouping by "URL" is good enough.
If you are piping the data into something that also facilitates Status Tracking data columns, you should expose the status of remediation efforts for that Product to the public.

High level overview of How Reporter Works

User fills out a form, some fields are automatically picked up, i.e. URL, firefox build etc
User submits form. Under the hood, a POST request is sent over HTTP, via XMLHttpRequest object, to some designated Web Service.
The Web Service enters form data into it's database and throws back a response.
Reporter renders success/failure page.

Anatomy of the Reporter Extension
In source code, Reporter lives in root/extensions/reporter. Layout of source code is shown to the right. For clarity, only the tweaked source files are shown.

After compilation and packaging, the resources folder becomes bin/chrome/reporter.jar. The locales section is merged into bin/chrome/en-US.jar/locale/en-US/reporter.

Privacy Notice -> Splash Page

Let's start by customizing the Privacy Notice dialog -- the very first thing our end-users will see when reporting a broken web site. Caveat: to disable the dialog that asks the user to acknowledge Mozilla's Privacy Policy, set extensions.reporter.hidePrivacyStatement in your global/default settings. I default this setting to true via Mission Control but using GPOs or CCK just to get that pref into the profile will work as well.

resources/skin/classic/reporter/firefoxlogo.gif -
Any changes to the file name have to be reflected in reportWziard.xul (below). I replace the logo with the logo of my team, to visually indicate to the user that they are, in fact, interacting with my internal system. My image is a gif, sized 350x133 pixels.

resources/content/reporter/reportWizard.xul - any changes to logo or layout of splash page happen here
This is what I have:

<!-- Privacy Notice -->
<wizardpage id="privacyNotice"
onpageshow="initPrivacyNotice()"
label = "&privacyNotice.label;">
<!--description>&reportWizardPrivacy.description;</description-->
<vbox id="privacyFrame" flex="1" style="padding:10px">
<hbox>
<html:img width="350px" height="133px"
src="chrome://reporter/skin/firefoxlogo.gif" />
</hbox>
<hbox height="100px"></hbox>
<hbox style="padding:4px;">
<description align="end" flex="1"
style="text-align:right;">&reportWizardPrivacy.description;</description>
</hbox>
</vbox>
</wizardpage>

locales/en_US/chrome/reportWizard.dtd - just changing text here...

<!ENTITY privacyNotice.label ""My" Firefox Reporter Agent">
<!ENTITY reportWizardPrivacy.description "This tool allows you to tell the MY.Team about web sites that do not work properly in &brandShortName;, or shut &brandShortName; out. This is your way to help us ensure the best possible experience for &brandShortName; users.">

Report Form

resources/content/reporter/reportWizard.xul - only change is in disabling the textbox (since it will auto-populate)

 <row align="center">
<label control="email" value="&reportForm.email.title;" accesskey="&reportForm.email.accesskey;"/>
<textbox id="email" size="60" class="noborder" disabled="true"/>
</row>

locales/en_US/chrome/reportWizard.dtd - only cosmetic changes here as well...

<!ENTITY reportForm.email.title  "Username (Required):">
<!ENTITY reportForm.email.accesskey  "U">

resources/content/reporter/reportWizard.js - the username is pulled from the environment in this snippet. getUsername() is the function of interest.

function initForm() {
var strbundle=document.getElementById("strings");
var reportWizard = document.getElementById('reportWizard');

reportWizard.canRewind = true;
document.getElementById('url').value = gURL;
document.getElementById('email').value = getUsername();

// Change next button to "submit report"
reportWizard.getButton('next').label = strbundle.getString("submitReport") + " >";

// We don't let the user go forward until they fufill certain requirements - see validateform()
reportWizard.canAdvance = false;
}

function getUsername() {
var env = Components.classes["@mozilla.org/process/environment;1"]
.getService(Components.interfaces.nsIEnvironment);

var username = env.get('USERNAME');
return username;
}

Send Data
All interesting pieces happen under the hood. In my environment, a SOAP envelope is constructed from the input form and is sent via XMLHttpRequest to a Sharepoint 2003 list. Obviously the implementation will have to be tweaked to work in your specific environment. However, the process of gathering and sending data over REST via XMLHttpRequest object should not change. Please explore the full listing of reportWizard.js available below.

Note-worthy areas are:

const declarations - POST parameters: url, operationName, listName, soapAction, myXMLNS, actionURI
prepareRequest() - converts form data into a qualified SOAP envelope for Sharepoint. See Example Envelop comment in the function.
callReporter() - executes the AJAX POST against the server and depending on response prepares the Results pane of the wizard
sendReport() - this is the master function, it pulls visible and hidden data from the form, stuffs it into an Array, calls prepareRequest() to convert the array into the SOAP envelope, and finally, calls callReporter() to fire off the data to my Sharepoint server.

The Results Page
At this point, our submission either succeeded or not. A report.xhtml or an error.xhtml page are rendered into an iframe on the final screen. These pages are dynamically populated by JavaScript.

resources/content/reporter/reportWizard.xul

<!-- Finish -->
<wizardpage id="finish"
     label="&finish.label;">
<textbox id="finishSummary" size="60" readonly="true"/>
<hbox>
<checkbox id="showDetail" label="&reportResults.showDetail.title;" accesskey="&reportResults.showDetail.accesskey;" oncommand="showDetail()"/>
</hbox>
<vbox id="finishExtendedFrame" flex="1">
<iframe id="finishExtendedSuccess" type="content" src="report.xhtml" flex="1"/>
<iframe id="finishExtendedFailed" type="content" src="error.xhtml" flex="1"/>
</vbox>
</wizardpage>

</wizard>

resources/content/reporter/report.xhtml


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" [
<!ENTITY % reporterDTD SYSTEM "chrome://reporter/locale/reportResults.dtd" >
%reporterDTD;
]>
<!-- ***** BEGIN LICENSE BLOCK *****
- Version: MPL 1.1/GPL 2.0/LGPL 2.1
-
- The contents of this file are subject to the Mozilla Public License Version
- 1.1 (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
- http://www.mozilla.org/MPL/
-
- Software distributed under the License is distributed on an "AS IS" basis,
- WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- for the specific language governing rights and limitations under the
- License.
-
- The Original Code is Mozilla Reporter (r.m.o).
-
- The Initial Developer of the Original Code is
-      Robert Accettura <robert@accettura.com>.
-
- Portions created by the Initial Developer are Copyright (C) 2004
- the Initial Developer. All Rights Reserved.
-
- Contributor(s):
-
- Alternatively, the contents of this file may be used under the terms of
- either the GNU General Public License Version 2 or later (the "GPL"), or
- the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- in which case the provisions of the GPL or the LGPL are applicable instead
- of those above. If you wish to allow use of your version of this file only
- under the terms of either the GPL or the LGPL, and not to allow others to
- use your version of this file under the terms of the MPL, indicate your
- decision by deleting the provisions above and replace them with the notice
- and other provisions required by the LGPL or the GPL. If you do not delete
- the provisions above, a recipient may use your version of this file under
- the terms of any one of the MPL, the GPL or the LGPL.
-
- ***** END LICENSE BLOCK ***** -->
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>reporter</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link rel="stylesheet" type="text/css" href="chrome://reporter/skin/reportResults.css"/>
</head>
<body>
<table>
<tr>
<th>&reportSite;:</th>
<td><span id="urlStri"/></td>
</tr>
<tr>
<th>&reportProblemType;:</th>
<td><span id="problemTypeStri"/></td>
</tr>
<tr>
<th>&reportDecsription;:</th>
<td><span id="descriptionStri"/></td>
</tr>
<tr>
<th>&reportPlatform;:</th>
<td><span id="platformStri"/></td>
</tr>
<tr>
<th>&reportProduct;:</th>
<td><span id="productStri"/></td>
</tr>
<tr>
<th>&reportoscpu;:</th>
<td><span id="oscpuStri"/></td>
</tr>
<tr>
<th>&reportGecko;:</th>
<td><span id="geckoStri"/></td>
</tr>
<tr>
<th>&reportBuildConfig;:</th>
<td><span id="buildConfigStri"/></td>
</tr>
<tr>
<th>&reportUseragent;:</th>
<td><span id="userAgentStri"/></td>
</tr>
<tr>
<th>&reportLanguage;:</th>
<td><span id="langStri"/></td>
</tr>
<tr>
<th>&reportEmail;:</th>
<td><span id="emailStri"/></td>
</tr>
</table>
</body>
</html>

resources/content/reporter/error.xhtml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" [
<!ENTITY % reporterDTD SYSTEM "chrome://reporter/locale/reportResults.dtd" >
%reporterDTD;
]>
<!-- ***** BEGIN LICENSE BLOCK *****
- Version: MPL 1.1/GPL 2.0/LGPL 2.1
-
- The contents of this file are subject to the Mozilla Public License Version
- 1.1 (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
- http://www.mozilla.org/MPL/
-
- Software distributed under the License is distributed on an "AS IS" basis,
- WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- for the specific language governing rights and limitations under the
- License.
-
- The Original Code is Mozilla Reporter (r.m.o).
-
- The Initial Developer of the Original Code is
-      Robert Accettura <robert@accettura.com>.
-
- Portions created by the Initial Developer are Copyright (C) 2004
- the Initial Developer. All Rights Reserved.
-
- Contributor(s):
-
- Alternatively, the contents of this file may be used under the terms of
- either the GNU General Public License Version 2 or later (the "GPL"), or
- the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- in which case the provisions of the GPL or the LGPL are applicable instead
- of those above. If you wish to allow use of your version of this file only
- under the terms of either the GPL or the LGPL, and not to allow others to
- use your version of this file under the terms of the MPL, indicate your
- decision by deleting the provisions above and replace them with the notice
- and other provisions required by the LGPL or the GPL. If you do not delete
- the provisions above, a recipient may use your version of this file under
- the terms of any one of the MPL, the GPL or the LGPL.
-
- ***** END LICENSE BLOCK ***** -->

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>reporter</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<link rel="stylesheet" type="text/css" href="chrome://reporter/skin/reportResults.css"/>
</head>
<body>
<h3>&error;</h3>
<div id="messagediv"><b>Error Code: </b><span id="faultCode"/><br/><b>Error Message: </b><span id="faultMessage"/></div>
</body>
</html>

Full Listing of reportWizard.js

/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Reporter (r.m.o).
*
* The Initial Developer of the Original Code is
*      Robert Accettura .
*
* Portions created by the Initial Developer are Copyright (C) 2004
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*    Boris Zbarsky 
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */

/********************************************************
*                *** Warning ****
*   DO _NOT_ MODIFY THIS FILE without first contacting
*   Robert Accettura 
*   or a reporter.mozilla.org Admin!
*******************************************************/

const gURL = window.arguments[0];
const gLanguage = window.navigator.language;
const gRMOvers = "0.2"; // Do not touch without contacting reporter admin!

// Globals
var gReportID;
var gSysID;
var gFaultCode;
var gFaultMessage;
var gSOAPerror = false;
var gPrefBranch;
const gAsync = false;
var gButton;
var reportWizard;

var myRequest;
var xmlEnvelope;
var consoleService;
/* SOAP Services for Sharepoint 2003 */
const url = 'http://myshareporint/sites/MyMozillaSite/_vti_bin/Lists.asmx';
const operationName = 'UpdateListItems';
const listName = 'MyReporterList';
const soapAction = 'SOAPAction';
const myXMLNS = 'http://schemas.microsoft.com/sharepoint/soap/';
const actionURI = myXMLNS+operationName;


function getReporterPrefBranch() {
if (!gPrefBranch) {
gPrefBranch = Components.classes["@mozilla.org/preferences-service;1"]
                .getService(Components.interfaces.nsIPrefService)
                .getBranch("extensions.reporter.");
}
return gPrefBranch;
}


function getBoolPref(prefname, aDefault) {
try {
var prefs = getReporterPrefBranch();
return prefs.getBoolPref(prefname);
} catch(ex) {
return aDefault;
}
}


function getCharPref(prefname, aDefault) {
try {
var prefs = getReporterPrefBranch();
return prefs.getCharPref(prefname);
} catch(ex) {
return aDefault;
}
}


function initPrivacyNotice() {
var strbundle=document.getElementById("strings");
var reportWizard = document.getElementById('reportWizard');

// Change next button to "submit report"
reportWizard.getButton('next').label = "Next >";

reportWizard.canRewind = false;
reportWizard.canAdvance = true;
}

function setPrivacyPref(){
if (document.getElementById('dontShowPrivacyStatement').checked){
var prefs = getReporterPrefBranch();
prefs.setBoolPref("hidePrivacyStatement", true);
}
}

function initForm() {
var strbundle=document.getElementById("strings");
var reportWizard = document.getElementById('reportWizard');

reportWizard.canRewind = true;
document.getElementById('url').value = gURL;
document.getElementById('email').value = getUsername();

// Change next button to "submit report"
reportWizard.getButton('next').label = strbundle.getString("submitReport") + " >";

// We don't let the user go forward until they fufill certain requirements - see validateform()
reportWizard.canAdvance = false;
}

function getUsername() {
var env = Components.classes["@mozilla.org/process/environment;1"]
 .getService(Components.interfaces.nsIEnvironment);

var username = env.get('USERNAME');
return username;
}

function validateForm() {
var canAdvance = document.getElementById('problem_type').value != "0";
document.getElementById('reportWizard').canAdvance = canAdvance;
}


function registerSysID(){
var param = new Array();;
param[0] = new SOAPParameter(gLanguage, "language");

// get sysID
callReporter("register", param, setValSysID);

// saving
if (gSysID != undefined){
var prefs = getReporterPrefBranch();
prefs.setCharPref("sysid", gSysID);
return gSysID;
}
return "";
}


function getSysID() {
var sysId = getCharPref("sysid", "");
if (sysId == "")
//sysId = registerSysID();

return sysId;
}

function sendReport() {
// we control the user path from here.
var reportWizard = document.getElementById('reportWizard');

reportWizard.canRewind = false;
reportWizard.canAdvance = false;
// why would we need a cancel button?
reportWizard.getButton("cancel").disabled = true;

var strbundle=document.getElementById("strings");
var statusDescription = document.getElementById('sendReportProgressDescription');
var statusIndicator = document.getElementById('sendReportProgressIndicator');

// Data from form we need
var myData = new Array();
myData['rmoVers']  = gRMOvers;
myData['url']  = gURL;
myData['problem_type']  = document.getElementById('problem_type').value;
myData['description']  = document.getElementById('description').value;
myData['behind_login']  = (document.getElementById('behind_login').checked ? 'Yes' : 'No');
myData['platform'] = navigator.platform;
myData['oscpu']  = navigator.oscpu;

myData['gecko']  = getGecko();
myData['product']  = getProduct();
myData['useragent'] = navigator.userAgent;
myData['buildconfig'] = getBuildConfig();
myData['language'] = gLanguage;
myData['email']   = document.getElementById('email').value;
myData['sysid']  = getSysID();

//build XMLHttpRequest
consoleService = Components.classes['@mozilla.org/consoleservice;1'].getService(Components.interfaces.nsIConsoleService);

doLog("init(): creating xmlEnvelope");
xmlEnvelope = prepareRequest(operationName,listName,myData);

var s = new XMLSerializer();
//var strMessage = s.serializeToString(xmlEnvelope);
doLog("doc: "+s.serializeToString(xmlEnvelope));

statusIndicator.setAttribute("value", "5%");
statusDescription.setAttribute("value", strbundle.getString("sendingReport"));

//CALL REPORTER
callReporter(operationName, xmlEnvelope); //setValReportID);

var finishSummary = document.getElementById('finishSummary');
var finishExtendedFailed = document.getElementById('finishExtendedFailed');
var finishExtendedSuccess = document.getElementById('finishExtendedSuccess');
if (!gSOAPerror) {
// If successful
finishExtendedFailed.setAttribute("class", "hide");

statusIndicator.setAttribute("value", "95%");
statusDescription.setAttribute("value", strbundle.getString("reportSent"));

reportWizard.canAdvance = true;
statusIndicator.setAttribute("value", "100%");

// Send to the finish page
reportWizard.advance();

// report ID returned from the web service
finishSummary.setAttribute("value", strbundle.getString("successfullyCreatedReport") + " " + gReportID);

finishExtendedDoc = finishExtendedSuccess.contentDocument;
finishExtendedDoc.getElementById('urlStri').textContent         = myData['url'];
finishExtendedDoc.getElementById('problemTypeStri').textContent = myData['problem_type'];
finishExtendedDoc.getElementById('descriptionStri').textContent = myData['description'];
finishExtendedDoc.getElementById('platformStri').textContent    = myData['platform'];
finishExtendedDoc.getElementById('oscpuStri').textContent       = myData['oscpu'];
finishExtendedDoc.getElementById('productStri').textContent     = myData['product'];
finishExtendedDoc.getElementById('geckoStri').textContent       = myData['gecko'];
finishExtendedDoc.getElementById('buildConfigStri').textContent = myData['buildconfig'];
finishExtendedDoc.getElementById('userAgentStri').textContent   = myData['useragent'];
finishExtendedDoc.getElementById('langStri').textContent        = myData['language'];
finishExtendedDoc.getElementById('emailStri').textContent       = myData['email'];

reportWizard.canRewind = false;
} else {
doLog('Failed to update list!');
// If there was an error from the server
finishExtendedSuccess.setAttribute("class", "hide");

// Change the label on the page so users know we have an error
var finishPage = document.getElementById('finish');
finishPage.setAttribute("label",strbundle.getString("finishError"));

reportWizard.canAdvance = true;
reportWizard.advance();

finishSummary.setAttribute("value",strbundle.getString("failedCreatingReport"));

finishExtendedDoc = finishExtendedFailed.contentDocument;
finishExtendedDoc.getElementById('faultCode').textContent = gFaultCode;
finishExtendedDoc.getElementById('faultMessage').textContent = gFaultMessage;
}
document.getElementById('finishExtendedFrame').collapsed = true;
reportWizard.canRewind = false;
reportWizard.getButton("cancel").disabled = true;
}


function showDetail() {
var hideDetail = document.getElementById('showDetail').checked ? false : true;
document.getElementById('finishExtendedFrame').collapsed = hideDetail;
}


function getBuildConfig() {
// bz and Biesi are my heroes for writing/debugging this chunk.
try {
netscape.security.PrivilegeManager
.enablePrivilege("UniversalXPConnect UniversalBrowserRead UniversalBrowserWrite");
var ioservice =
Components.classes["@mozilla.org/network/io-service;1"]
    .getService(Components.interfaces.nsIIOService);
var channel = ioservice.newChannel("chrome://global/content/buildconfig.html", null, null);
var stream = channel.open();
var scriptableInputStream =
Components.classes["@mozilla.org/scriptableinputstream;1"]
    .createInstance(Components.interfaces.nsIScriptableInputStream);
scriptableInputStream.init(stream);
var data = "";
var curBit = scriptableInputStream.read(4096);
while (curBit.length) {
data += curBit;
curBit = scriptableInputStream.read(4096);
}
// Strip out the  part, since it's not valid XML
data = data.replace(/^]*>/, "");
// Probably not strictly needed, but what the heck
data = data.replace(/^/, "");
var parser = new DOMParser();
var buildconfig = parser.parseFromString(data, "application/xhtml+xml");
var text = buildconfig.getElementsByTagName("body")[0].textContent;
var start= text.indexOf('Configure arguments')+19;
return text.substring(start);
} catch(ex) {
dump(ex);
return "Unknown";
}
}

// Execute an AJAX call
function callReporter(method, message) {
//var serviceURL = getCharPref("serviceURL", myServiceURL);

doLog("init(): sending request to "+url);
myRequest = new XMLHttpRequest();

myRequest.onreadystatechange=function() {
if (myRequest.readyState==4) {
if (myRequest.status==200) {
doLog("URL Exists!");
doLog(myRequest.getAllResponseHeaders());
doLog(myRequest.responseText);
alert("URL '"+url+"' exists");
alert(myRequest.responseText);
} else if(myRequest.status==404) {
doLog("URL doesn't exist!");

} else if(myRequest.status==500) {
doLog("Server Failed "+myRequest.status);
doLog("theResponse: "+myRequest.responseText);
gSOAPerror = true;
gFaultCode = myRequest.status;
gFaultMessage = myRequest.responseText;
} else {
doLog("unknown error!");
gSOAPerror = true;
doLog("Server Failed "+myRequest.status);
doLog("theResponse: "+myRequest.responseText);
}
}
};

doLog("xmlEvenlope: Serialized -- "+message);

try{
myRequest.open("POST", url,gAsync);
myRequest.setRequestHeader(soapAction,actionURI);
myRequest.setRequestHeader('Content-Type','text/xml');
doLog("myRequest: "+myRequest);
myRequest.send(message);
doLog("myRequest: sent -- \n"+message);

if(!gAsync) {
if(myRequest.status != 200) {
gSOAPerror = true;
gFaultCode = myRequest.status;
gFaultMessage = myRequest.responseText;
}
}
} catch(e) {
doLog("exception: "+e);
}
}


function setValSysID(results) {
if (results) {
var params = results.getParameters(false,{});
for (var i = 0; i < gsysid =" params[i].value;" params =" results.getParameters(false,{});" i =" 0;" greportid =" params[i].value;" appinfo =" Components.classes[" appinfo =" Components.classes[" doc =" document.implementation.createDocument(myXMLNS," env =" document.createElement(" body =" document.createElement(" operation =" document.createElement(" listname =" document.createElement(" op ="=" op ="=" env="http://schemas.xmlsoap.org/soap/envelope/" xsi="http://www.w3.org/2001/XMLSchema-instance" xsd="http://www.w3.org/2001/XMLSchema">ReporterNewkrylovy
*/

// XML document
var Updates = document.createElement("a0:updates");
Operation.appendChild(Updates);

var Batch = document.createElement("Batch");
Batch.setAttribute("OnError","Return");
Batch.setAttribute("ListVersion","1");
Updates.appendChild(Batch);

var Method = document.createElement("Method");
Method.setAttribute("ID","1");
Method.setAttribute("Cmd","New");
Batch.appendChild(Method);

var Field;
var key;

//one-time operations
Field = createField('ID','New');
Method.appendChild(Field);

Field = createField('Title',data['url']);
Method.appendChild(Field);

for(key in data) {
doLog('key: '+key+' value: '+data[key]);
Field = createField(key,data[key]);
Method.appendChild(Field);
}
}
return Doc;
}

function createField(key,value) {
var field = document.createElement('Field');
field.setAttribute('Name',key);

var text = document.createTextNode(value);
field.appendChild(text);

return field;
}

function doLog(aMessage) {
consoleService.logStringMessage("MSReporter: "+aMessage);
}

Full Listing of reportWizard.xul

<?xml version="1.0"?>
<!-- ***** BEGIN LICENSE BLOCK *****
- Version: MPL 1.1/GPL 2.0/LGPL 2.1
-
- The contents of this file are subject to the Mozilla Public License Version
- 1.1 (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
- http://www.mozilla.org/MPL/
-
- Software distributed under the License is distributed on an "AS IS" basis,
- WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- for the specific language governing rights and limitations under the
- License.
-
- The Original Code is Mozilla Reporter (r.m.o).
-
- The Initial Developer of the Original Code is
-      Robert Accettura <robert@accettura.com>.
-
- Portions created by the Initial Developer are Copyright (C) 2004
- the Initial Developer. All Rights Reserved.
-
- Contributor(s):
-
- Alternatively, the contents of this file may be used under the terms of
- either the GNU General Public License Version 2 or later (the "GPL"), or
- the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- in which case the provisions of the GPL or the LGPL are applicable instead
- of those above. If you wish to allow use of your version of this file only
- under the terms of either the GPL or the LGPL, and not to allow others to
- use your version of this file under the terms of the MPL, indicate your
- decision by deleting the provisions above and replace them with the notice
- and other provisions required by the LGPL or the GPL. If you do not delete
- the provisions above, a recipient may use your version of this file under
- the terms of any one of the MPL, the GPL or the LGPL.
-
- ***** END LICENSE BLOCK ***** -->
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<?xml-stylesheet href="chrome://reporter/skin/reportWizard.css" type="text/css"?>

<!DOCTYPE wizard [
<!ENTITY % brandDTD SYSTEM "chrome://branding/locale/brand.dtd">
%brandDTD;
<!ENTITY % reportWizardDTD SYSTEM "chrome://reporter/locale/reportWizard.dtd">
%reportWizardDTD;
]>

<wizard id="reportWizard" title="&reportWizard.title;"
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
xmlns:html="http://www.w3.org/1999/xhtml">
<script type="application/x-javascript" src="chrome://reporter/content/reportWizard.js"/>
<stringbundle id="strings" src="chrome://reporter/locale/reportWizard.properties"/>

<!-- Privacy Notice -->
<wizardpage id="privacyNotice"
    onpageshow="initPrivacyNotice()"
    label = "&privacyNotice.label;">
<!--description>&reportWizardPrivacy.description;</description-->
<vbox id="privacyFrame" flex="1" style="padding:10px">
<hbox>
<html:img width="350px" height="133px" src="chrome://reporter/skin/firefoxlogo.gif" />
</hbox>
<hbox height="100px"></hbox>
<hbox style="padding:4px;">
<description align="end" flex="1" style="text-align:right;">&reportWizardPrivacy.description;</description>
</hbox>
</vbox>
</wizardpage>

<!-- Report Form -->
<wizardpage id="reportForm"
    onpageshow="initForm()"
    label="&reportForm.label;">
<description>&reportForm.description;</description>
<separator />
<grid>
<columns>
<column/>
<column flex="1"/>
</columns>
<rows>
<row align="center">
<label control="url" value="&reportForm.url.title;"/>
<textbox id="url" size="60" readonly="true" class="noborder"/>
</row>
<row align="center">
<spacer/>
<checkbox id="behind_login" label="&reportForm.behind_login.title;" accesskey="&reportForm.behind_login.accesskey;"/>
</row>
<row align="center">
<label control="problem_type" value="&reportForm.problem_type.title;" accesskey="&reportForm.problem_type.accesskey;"/>
<!-- XXX: Perhaps this should eventually/maybe come from somewhere else?  Eh, not sure so lets just hardcode this for now. -->
<menulist label="problem_type" id="problem_type" oncommand="validateForm()">
  <menupopup>
    <!-- ************* WARNING *************** -->
    <!-- DO *NOT* Add/change/modify without consulting with r.m.o server admin first! -->
    <!-- ************ /WARNING *************** -->
    <menuitem label="&reportForm.problem_type.chooseOne.title;" value="0"/>
    <menuitem label="&reportForm.problem_type.item1.title;" value="1"/>
    <menuitem label="&reportForm.problem_type.item2.title;" value="2"/>
    <menuitem label="&reportForm.problem_type.item3.title;" value="3"/>
    <menuitem label="&reportForm.problem_type.item4.title;" value="4"/>
    <menuitem label="&reportForm.problem_type.item5.title;" value="5"/>
    <menuitem label="&reportForm.problem_type.item6.title;" value="6"/>
    <menuitem label="&reportForm.problem_type.item7.title;" value="7"/>
  </menupopup>
</menulist>
</row>
<row>
<label control="description" value="&reportForm.describe.title;" accesskey="&reportForm.describe.accesskey;"/>
<textbox id="description" value="" cols="40" rows="5" multiline="true" size="40" class="noborder"/>
</row>
<row align="center">
<label control="email" value="&reportForm.email.title;" accesskey="&reportForm.email.accesskey;"/>
<textbox id="email" size="60" class="noborder" disabled="true"/>
</row>
<!--row align="center">
<spacer/>
<hbox>
  <label id="privacyPolicy" class="text-link"
         value="&reportForm.privacyPolicy.title;"
         tooltiptext="&reportForm.privacyPolicy.tooltip;"/>
</hbox>
</row-->
</rows>
</grid>
</wizardpage>

<!-- Send Data -->
<wizardpage id="sendReport"
    onpageshow="sendReport()"
    label="&sendReport.label;">
<description>&sendReport.description;</description>
<separator />
<description id="sendReportProgressDescription"/>
<progressmeter id="sendReportProgressIndicator" mode="undetermined" value="0%"/>
</wizardpage>

<!-- Finish -->
<wizardpage id="finish"
    label="&finish.label;">
<textbox id="finishSummary" size="60" readonly="true"/>
<hbox>
<checkbox id="showDetail" label="&reportResults.showDetail.title;" accesskey="&reportResults.showDetail.accesskey;" oncommand="showDetail()"/>
</hbox>
<vbox id="finishExtendedFrame" flex="1">
<iframe id="finishExtendedSuccess" type="content" src="report.xhtml" flex="1"/>
<iframe id="finishExtendedFailed" type="content" src="error.xhtml" flex="1"/>
</vbox>
</wizardpage>

</wizard>

Testing and Packaging
Backup the .jar's with Reporter's components. For quick/dirty tests, simply open up each of the aforementioned jars with something like WinRAR and simply overwrite/add the pristine files with your version. Changes should take effect after restart of the browser.

Optionally, and I have not done this, you can create the manifests and treat reporter as just another extension under development. This is probably the best way to go if changes to the extension are significant.

My team compiles our own version of Firefox for internal distribution. Changes to the reporter extension are part of our "pre-build" process. Luckily, this extension has not changed over the lifetime of Firefox 2.

Other options are simply to use CCK or a wrapper to drop in your replacement jars prior to roll-out.

Spread the word
Users need to know that the "Report a Broken Website..." has been customized and is available for use. Within a few weeks we accumulated over 300 entries with around 10 unique sites making our "To be Remediated List". Yeah, I wussed out on the "Wall of Shame" title =)

Wrap up
Hopefully, the walk-through illustrated some strategies in customizing the Reporter extension. Although my example publishes to Sharepoint in SOAP format, the mechanisms for submitting to any Web Service are standard and should be fairly straight-forward to customize for your own needs. The resulting Dashboard/Reporting aspect is community-friendly and provides useful statistics to guide the prioritization of remediation work.

Errata will certainly follow in the form of comments and I of course welcome corrections, opinions, feedback and your own stories from the frontier. Cheers.

Taking Baby Steps (part 4): The Ten-Step Plan

2008-01-23T01:28:00.000-05:00

Here it is. Feedback is always welcome. Naturally.

Need a Blog: Pick a Blogging platform but do your best to leverage an in-house platform, if one exists. Please, do not simply download some Blogging software into your work environment. Reach out to your friendly, neighborhood IT dept for guidance.
Put a project into your "lab": Pick a small project that can benefit from improved transparency. By "small" I mean one that is not super critical and one that you have some leeway to experiment with. These tend to be the types of projects where Delivering is your primary responsibility and not Joe's...
Don't overdo it: Establish guidelines about what kind of information is worth "tracking". I've outlined some ideas in my previous posts ("Taking Baby Steps" series). In essence, establish a Knowledge Base of some sort, even if you have to cobble something together. Don't over-engineer your posts. Like a good workout program, keep it lively, keep it real, reduce obstacles so you can sustain.
Dogfood: Spend a few weeks being selfish and commit information to the KB that helps you be successful on your project.
Dangle the carrot: Give the link or RSS Feed to this KB to your manager and your team-mates. Use the content as a basis for your meeting agendas and follow-ups. Work on getting your colleagues to read your post prior to the meetings. One way to do this is to send a plain-old-email with a link to your post an hour ahead of a meeting. Make it clear that the meeting will cover the agenda enumerated there and you'd like to spend less time regurgitating and spend more time decision-making.
Aggressively seek the ever-elusive "manager" comments on your blog. Period. Your efforts will not succeed without a completed Feedback loop. Active participation is key.
Manage expectations: This is not a be all, end all solution. Make sure that your social network is aware of this fact.
Tag it up: Create a taxonomy of "special" Tags and standardize them. That is agree, for example, that all weekly summaries posted to individual product blogs should be Tagged as "weekly" and that all 2-week look-aheads should be Tagged as "iteration".
Roll it up: Construct a Dashboard Tab that may be of value to your manager's manager by rolling up RSS feeds filtered by your "weekly" and "iteration" tags. Get your manager's, manager's manager to acknowledge its usefulness. If you can pull this off, send me an email and I will honor you with the Order of Blogging Ninja.
Road show: Leverage your network to identify like-minded individuals who will benefit from a similar set up. Document the set-up process, best practices and your experiences on a Wiki as you explain the process to your buddy. Encourage your buddy to contribute to this Wiki as (s)he works out the implementation and goes through the process. Rinse and repeat. After a month or two, put together a Forum of sorts and present your findings to your department. Please don't be boring. Then, go to Disney World.

I'll let the 10th point act as the transition into the world of Wikis; coming up next.

Creating backups of Folders with C#.NET

2007-10-12T14:18:00.000-04:00

Zipping up folders for backup purposes with C# in .NET2 is painful. Using 3rd party libs is bulky. CodeProject and Geralrd Gibson Jr & Friends to the Rescue. And because regurgitation is useful for later retrieval, here is the "Silent Mode" code snippet that works for me:

internal void Backup()
{
  LogHelper.Info(String.Format("Backing up Folder to {0}...", Config.General.ApplicationDataDir));
  string backupFolder = String.Concat(Config.General.ApplicationDataDir,Config.General.DirectorySeparatorStr,"Backup");
  string backupZip = String.Concat(backupFolder,Config.General.DirectorySeparatorStr,"Backup_",DateTime.Now.ToFileTime(),".zip");
  if(!Directory.Exists(backupFolder)) Directory.CreateDirectory(backupFolder);
            
  byte[] emptyzip = new byte[]{80,75,5,6,0,0,0,0,0, 
                  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

  FileStream fs = File.Create(backupZip);
  fs.Write(emptyzip, 0, emptyzip.Length);
  fs.Flush();
  fs.Close();
  fs = null;

  //Copy a folder and its contents into the newly created zip file
  Shell32.ShellClass sc = new Shell32.ShellClass();
  Shell32.Folder SrcFlder = sc.NameSpace(Config.General.LocalRootPath);
  Shell32.Folder DestFlder = sc.NameSpace(backupZip); 
  //Shell32.FolderItems items = SrcFlder.Items();
  //1564 =
  //+ 4     Do not display a progress dialog box.
  //+ 16     Click "Yes to All" in any dialog box displayed.
  //+ 512     Do not confirm the creation of a new directory if the operation requires one to be created.
  //+ 1024 Do not display a user interface if an error occurs.
  DestFlder.CopyHere(SrcFlder, 1564);
}

Taking Baby Steps (part 3): Dashboards - A managerial love story

2007-09-24T14:21:00.000-04:00

Overview
Part 2 of this series "Taking Baby Steps (part 2): Only one person reads my Blog and I've already won" discussed some ways in which posts to personal, work-related Blogs (aka Knowledge Bases) are relevant to our team-mates and managers. Additionally, techniques on targeting posts through use of Tags were also presented.

In this 3rd post, I will talk about Dashboards, what they're for and how to set them up.

The Basic Unit of Information about which people relate at work
Projects.

Just the "sweet spot", please
There is an inverse relationship between someone's social proximity (in a "Social Degrees of Separation" sense) and their

Tolerance for Irrelevant Information
Amount of time willingly spent extrapolating "important" information

That is, the farther apart two people are in a socio-professional environment, the smaller their overlap of interests. Let's say 70% of my time is dedicated to Project A and 30% to Project B. My colleague Bob also dedicates 30% of his time to Project B. What this means is that out of all the information and knowledge I deal with on a daily basis, only 30% of it is relevant to Bob and I only have 30% of my time available to share this information.

Furthermore, depending on the roles being played, it is important to understand which 30% of Project B Bob focuses on. If Bob is the Project Manager, odds are that the details of your application's algorithm beyond a statement that "it works" is not very relevant to Bob. Including Bob in day-to-day, back-and-forth conversation about algorithm optimizations negatively impacts Bobs productivity given his slice of the pie. This should not be interpreted as "Bob should be left in the dark for the other 70%". Rather:

Amount of information sent through the pipe is important.
Quality of information is very important
Order of information is also important

Some elaboration. For example, most people skim through email until something of importance catches their eye. Then they will read around that which jumped out. This is an act of validation. The reader is Gauging and Confirming Level of Relevancy. As was stated earlier, we all have a threshold. Whether this is acknowledged or not, we all associate Quality of information relayed to us with the originator of the communication. We even have functionality built into our email clients to reward those sources of information that we believe to consistently relay High Quality information. People whose communications I wish to help penetrate through "my" noise get their own Mail Folder and a Rule. The Folder makes it into my Top 5 and so on. Rather than skimming I tend to read these communications "normally". High Quality/Highly Relevant information from the originator creates a level of Trust. Perhaps its a bit too cliche to claim that Trust allows for solid Feedback Loops. Rather, its very clear that a lack of Trust results in a well stocked Trash.

Ideally, communications to Bob are well targeted bringing the 30% of the project Bob is involved in to the forefront. (Bob thanks me for not wasting his time.)

A not so "Side Note". I really dislike emails that say "FYI" followed by a long thread of bracketed who-knows-what. Figuring out the part that is in fact For My Information will require me to skim not just one email, but all the accompanying threads. Cliff Notes at the top, please!

Information Trickle
Why do "executive" summaries exist everywhere but in our routine communications within our Social Networks? The "Cliff Notes" quip above actually deserves some discussion. Clues about content subject matter and how it pertains to "me" are very helpful because they grant me the opportunity to cash out sooner rather than later. Tags are great but not as great as a one-sentence summary that speaks right to my forehead. Descriptive titles/subjects also help a great deal!

Whether we skim, or jump back and forth as we consume written information, it is still done (for must of us) in a linear way. Pardon the nerdy analogy but this is like a Disk Head tracking back and forth over a Hard Drive. Meta information about files, directories etc in all File Systems is also at the "top". Search Engines construct indexes that pull out relevant information so that from then on the engine can gauge a match - "this data is relevant" - as quickly and efficiently as possible. There are many other examples of almost identical optimizations that happen in technology because we demand it. Somehow, similar optimizations fail to make it into routine meeting, emails, phone conversations, and so on. It would be nice to have that Trickle from High Level but High Quality information to Low Level details in all mediums of communication.

Dashboards are about creating this kind of Information Trickle for other forms of Project-related information.

Dashboards and RSS Feeds go hand in hand

My Dashboard at work contains the following:

Tab 1: 20,000 feet -
Idea here is to create that High-level but informative "At-A-Glance" View of team-wide activity. This High Level but High Quality landing page is relevant to anyone who may be interested in the activities of the team. For a manager 1 or more Social Degrees away, this is a good place to begin "dipping" into our "world" without being overwhelmed by all the details. For my team-mates, this Tab can serve as the Sync-Point for meeting agendas, follow-ups, Iteration refinement and so on. My team-mates will most likely want/need to drill deeper, the manager 1 or more Social Degrees away will not!

Specifically, our first Tab contains:

Changes to Production - Feeds that describe changes to portions of the "production" environment we are responsible for. This is a feed coming out of our Turnover Control System. It's not RSS at this point but hopefully will be soon.
Work plan for the entire team spanning 2 weeks time (this is the Two-week Iteration). This is just an aggregate feed that collates Two-week Iterations from individual product blogs based on the "iteration" Tag.
Top 5 Bugs or Issues spanning all our products. This is yet another RSS Feed filtered for items tagged or flagged as "important" from our issue tracking system.
Links that allow the reader to subscribe to any of the RSS feeds exposed on the page

Tab 2-x: Product-specific pages
Each of these Tabs is dedicated to a specific Product/Project the team works on. These tabs are a natural "drill-target" from the 1st Tab. My Product Tabs contain:

Changes to productions affecting this specific product
Iteration posts for this product. This is a regular RSS Feed coming form my Product Blog filtered on the "iteration" tag.
News Items or Alerts coming from the Blog or the Product Site. (The Product Site tends to target the end-user/customer. It's not very technical but provides enough insight about the Product's stage in it's life cycle, and the standard "what" and "how")
Top 5 Bugs or Issues for this specific product/project
Links that allow the reader to subscribe to any of the RSS feeds exposed on the page

RSS Feeds are a natural way to "summarize" content that lives elsewhere. As you can see, no content is actually managed by the Dashboard. The Dashboard simply assembles information into easily consumable pieces. The Trickle is enabled by:

At-a-Glance views of tightly-correlated information
Ability to stay High-Level yet still obtain more detail. The reader can explore Product-specific Tabs without leaving the context of the Dashboard.
Link-backs to the source of information. The reader can drill even deeper by clicking on any item in any of the feeds and be taken to the full "article". The reader does this by choice - this is key.

Technologies at Play

Blogs with RSS capabilities -
Blogs tend to be more appropriate for Weekly Summaries and Iteration posts. My Blog allows me to publish via email so I don't have to change my habits to post. I publish from my Email Client.
RSS Web Part -
RSS is not just about getting news from slashdot. It can be a very powerful Glue for information that lives everywhere yet needs to be correlated in a single View.
A portal framework with a Tabs Layout -
The Sharepoints of the world all have this built in. Acquiring RSS Web Parts is also not too difficult. Some Wikis out there (like Twiki or Confluence) allow you to inject all sorts of content into a single page view, including RSS. These are all basic things. As always, your friendly neighborhood IT department will have some options for you.

How to get started
Naturally, I recommend taking "baby" steps. Most teams will fall into two categories:

A lot of unorganized documentation floating around in multiple formats
All project-related know-how is stored in the brain of the guy two weeks away from retirement

For folks that fall into the 1st group, it's a matter of figuring out the kind of information that is most useful to highlight on a dashboard. Some teams I've worked with went straight to:

Top Bugs
Testing Results
Latest activity around portfolio work for a client

Folks falling into the 2nd category should consider starting with Personal, Ad-hoc Knowledge Bases and expanding out from there.

In general, the type of information that is of Highest Value to your social network should be exposed first. The gains will be emergent and will inspire further investment into not just the Dashboards but also into creating and persisting the High Quality data underneath.

Conclusion and what's up next
Dashboards just front the Collaborative Environment. If the information in Product Blogs, Wikis, etc is not up-to-date, Dashboard's highlights are meaningless. It does take some work and consistency to provide this kind of transparency to your team, your manager and your customers.

Typically, gate-keeping Knowledge Bases and their Dashboards is the responsibility of Team Leads and Product or Project Managers. To get started though, all you need is a Champion, someone who will get the team going, while incrementally proving value. Once your manager is convinced (unless of course you are the manager) some top-down "encouragement" never hurts.

In my next post, I will propose a 10-Step Plan to putting these concepts to practice so we can move on to topics such as Wikis, Issue Tracking, and Interruption Management.

Firefox EWG - Meeting #3

2007-09-19T13:54:00.000-04:00

Summary
Call on Sept 19th was about useful Extensions for the Enterprise. A larger portion of the meeting, however focused on the apparent dwindling interest in Enterprise Firefox within the larger community.

Is the Enterprise simply not ready to bring Firefox in-house? Or, are the majority of institutional adopters simply happy with a consumer product floating about?

Perhaps one of the problems is that we still talk about Firefox as a Web Browser as opposed to a "Productivity Platform" for the Desktop.

Firefox is a Productivity Platform
All the features that make Firefox a consumer favorite deal with productivity. Tabs, keywords, search bars, extensions, dictionaries, etc help us be effective and productive in our work and home lives. When consumer says "better usability", enterprise says "better productivity".

Mike Kaply spoke about adoption at IBM. Developers are finding ways to enhance the end-user experience by writing custom extensions for Firefox. Whether the extensions glue several applications together or simply automate the tedious process of filling out web-forms, end result is a boost to productivity.

If Firefox is the gateway or glue between what's on the Desktop and what's on the network, potential for productivity-boosting application is something to ponder.

Raising awareness
Mike and I are going to take lead on a few initiatives to help raise awareness on the Enterprise Firefox front:

10 Steps to adopting Firefox in the Enterprise -
Now that we've begun to pool experiences, we should be able to bake out a definitive guide of sorts for things to consider when bringing Firefox into an enterprise environment
Good Ol' Conference -
We will begin looking at opportunities to present at some Conferences
Blogging - check...
Code Day and Training -
The learning curve for any kind of Mozilla-related development is rather high. Perhaps training targeting institutions and enterprises (like an Enterprise track) will help developers scale this wall.
Enterprise Firefox Incubator -
Talk has alway been cheap. As we address settings management, security, tools etc we will kick off projects within the Enterprise Working Group.

Enterprise Working Group Incubator
On my end, I'm going to kick off some projects for the Incubator. Specifically there has been interest in:

Mission Control - how to get up and running, what the back-end implementation can look like and benefits over GPO
Customized Reporter Extension - so that you can redirect Broken Website reports to a repository on your intranet
Managed Security Zones for Firefox - how to configure and lock capabilitiy.policy settings in Firefox, how to create a "trusted" zone and fully leverage Web2.0 technologies within your trusted intranet.

As always, if any of these topics or projects are of interest to you, please visit http://enterprisefirefox.org, participate in the calls or simply leave a comment on this here Blog.

Third Firefox Enterprise Working Group Meeting August 22nd

2007-08-20T21:04:00.000-04:00

Third call is scheduled for Wednesday, August 22th at 10:00am Pacific, 1:00pm Eastern, 17:00 UTC. Details:

650-903-0800 or 650-215-1282 x91 Conf# 280 (US/INTL)
1-800-707-2533 (pin 369) Conf# 280 (US)
IRC - irc.mozilla.org - #ewg

The theme is “Extensions.” Please check out the EWG Wiki page for more information.

Firefox EWG - Meeting #2

2007-08-08T13:17:00.000-04:00

Overview
This call focused on the Enterprise Wishlist. What are some common problems that need resolving and what features can we vote "up" as a Community?

Topics covered:

Addon Management

Do enterprises wish to control updates to addons or the application itself?
The general sentiment seems to be "yes". At one extreme an enterprise may wish to allow the user's browser to pull updates directly from Mozilla. At the other extreme, an enterprise may wish to provide an intermediary point so that all internal browsers pull updates from this point. The intermediary infrastructure then has to have a way of pulling latest updates from Mozilla, either manually or automatically.

So, first, we need to understand how to configure for each scenario. Second we need to understand how to set up our internal infrastructure to facilitate the second scenario.

Distribution

MSI packaging -This seems to be something everyone wants.

Ability to easily repackage the browser so we can add in our own "default" addons.

Distributors that create packages for others to deploy cannot use the Firefox brand as part of their package. However, enterprises that deploy for internal audience only can use the Firefox brand. Can we work through these issues to make distribution channels more accessible?

Settings Management

Group Policy - a non-trivial problem to solve. Need to work on proper GPO integration!

GPO vs Mission Control - pros and cons - will schedule a separate meeting to discuss these issues.

Security Zones

By design, Firefox does not allow cross-domain scripting. For an intranet, this can effectively break Web2.0 where developers want web technologies to federate. With IE, subdomains on a common domain are placed in a Trusted Security Zone. The relaxed security settings allow full-blow AJAX federation and interoperability. Similar capabilities exist in Firefox but they are no where near on par with IE.

Firefox has a notion of a "security setting". There are even policy.* settings that make it possible to simulate Security Zones. This is great! However, Firefox treats policy.* and other security settings differently from rest of the settings. In fact - according to Mike Kaply - it is a completely different API. Mission Control cannot manage these settings which means we can't enable them across the Firm. This is a real challenge. How can we allow Mission Control or GPOs to enable these settings in a managed manner?

Personal Musings
My team compiles our own version of Firefox from the latest "stable" source. We make no changes to the code base. Why do we do this?

Set our own version and timestamp info for the executable and the dlls. This helps us differentiate between "supported" Firefox and a "renegade" Firefox within the Firm. We actively discourage users from installing vanilla or "renegade" versions of anything. This is simply a security precaution for a Fortune 500. All software deployment goes through this pipeline. An unpatched Firefox within our environment that admits an exploit vector could be disastrous for business.
We enable and compile in the "Autoconfig" mode that allows us to run Mission Control for settings management.
We introduce some custom extensions and themes that we want to include in our package.
We drop in config files for Mission Control

Points 3 and 4 don't really have much to do with compilation. Using Mike Kaply's technique for repackaging Firefox (see here) we can drop in our custom stuff without having to re-compile. Points 1 and 2, however really prevent us from taking advantage of a third-party MSIs. In fact all packages of "vanilla" Firefox are pretty much useless to us.

My point, we really do need an Enterprise Firefox package that's separate from the Consumer package. But what is it? What's the common denominator? One enterprise will want to manage settings with GPOs. Another one will want Mission Control. A third will want both. Is it possible to instrument a flexible package that can be configured? Maybe asking enterprises to compile their own version is not such a big deal when instructions on doing so are bullet proof. Much to think about...

Agile Development Methodology

2007-07-31T10:52:00.001-04:00

The original version of this document was created and put into action by my friend and ninja, Azubuko (Buko) Obele while we worked at our first start-up. The document has since undergone some revisions as I've adopted it for my own purposes over time. This is an agile, iterative approach to product life-cycle management and it work in small and large firms alike. (Buko, you're a genius).

Processes and Methodologies

This document specifies recommendations for the software development process and the IT infrastructure strategy for developers and managers.

Overview

Philosophy

The intent of this document is to establish a foundation for development traditions and ultimately a company culture whose central philosphy of the development strategy is to maximize communication, collaboration, feedback and transparency. In doing so, the company will succeed in constructing an adaptive development infrastructure that can rapidly address changing business requirements and market realities.

Communication will ensure that the company's software and infrastructure development efforts are focused on addressing concrete business requirements.

Colaboration will allow the company to encapslate areas such as knowledge and distribution, reuse and automation, and proper allocation and management of resources. This will ensure productivity and efficiency.

Transparency will ensure that the company's development efforts are generating value and that risks are apparent.

Feedback will ensure that the development efforts are in fact meeting concrete business requirements and allow governence teams to understand the "current" situation and plan for the future.

Core Competency

Middle-tier vendors are moving into the forefront consolidating and standardizing services that may be purchased "off the shelf". This long list of solutions includes groupware solutions, Customer Resource Management (CRM) solutions, datasource abstraction tools, corporate communication tools, and enterprise-level SDKs and utilities among many. While it may "seem" easier to integrate vendor components, long-term customization and Quality of Service (QoS) costs may hinder the company's competitive edge. On the other hand there is no sense to "re-invent the wheel" especially when the middle-tier vendors have nearly perfected the services and components they sell.

Finally, it is always advantageous for the company to participate in IT Infrastructure Strategies mentorship and advisory programs offered by such industry leaders as the META Group, Inc.

Product Driven

Development Teams are encouraged to think in terms of "products" as opposed to "projects". A product is a deliverable with a well defined cost and risk and one that will create some well-defined value for the customer and company. A "product" should include all implementation, development, and operation costs of underlying infrustructure and application. The composite should be treated as part of the company's "portfolio". Tactical and Strategic methodologies will allow the company to effeciently grow and reassess the portfolio.

Tactical or "per-project" planning is conducted for each new application or infrustructure-driven project. The phases of Tactical planning are described as part of the Development Process section.

Strategic or "periodic" processes deal with periodic reassessment of the company's IT portflio, including Infrastructure Impact Assessment (IIA) and Prdictive Cost Modeling (PCM).

Agility and Velocity

The development process should capitalize on the company's energy and small size. The ability to quickly respond to evolving requirements and market conditions will allow the company to remain agile and adaptive. The ability to quickly initiate product development while sustaining a high, predicatble rate of development will allow the company to retain a high velocity. To accomplish this, the development process itself must follow "Agile" methodologies with a focus on Test-driven development while keeping unnecessary documentation and meetings to a minimum.

Risk Management

Enterprise-scale infrastructure deployment and large-scale software development is inherently a high-risk/high-rewards endeavor. Methodologies and processes must reduce risk whenever possible. Risk assessment must take complexity, time to market, and specific business-related value into account. Commitment to collaboration, communication, transparency and feedback will also help make high-risk scenarios manageable. Long-term projects with large iterations should be avoided as they tend to require large investments of time and resources and are inherently lacking in agility. It is recommended that focus is on test-driven development, continuous integration, short iterations to create immediate value and to produce tangible returns, centralization, and portfolio view of infrastructure patterns and services.

Development Process

Inception

The goal of the product inception phase is to identify and define the business problem. The result of the inception phase is a high-level description of the product's purpose and a non-exhaustive set of produt requirements. It should be clear from the onset who the product is used by, what "pain" the product should "cure" or "alleviate", what potential value the poduct brings to the company and in technology-neutral, abstract terms, what the product should do. How the product will work is irrelevant at this stage; only the Why and What matter. A product idea may only pass this phase if the risk is justified by value.

Business, Infrastructure, and Software development governance teams should be heavily involved in this process to present a holistic view of risk and reward. The deliverables of this phase should be (1) Meeting Notes and (2) Product Requisition Document (PRD).

Service Level Metrics, Feature Planning, Use Case Definition

The goal of this phase is to evaluate risk and to ultimately bring it under control. At this stage, the infrustructure planner should work with the product managers to define a potential solution and agree upon service levels. The product managers should describe a series of well-defined use cases and rate them in terms of risk. These use cases will describe the solution to the business problem from the application perspective.

Business specialists working with Software development management teams and Infrastructure planners should deliver a Feature Specification Document (FSD), Service Level Metrics Document (SLMD).

Development Planning

The primary goal of the stage is to bring the technical risks under control. Issues such as performance, scalability, reliability, and security should be addressed and metrics for product success should be established. The infrastructure planner should leverage as much existing infrastructure as possible, and infrastructure standards and processes where innovation allows. The planner should propose a blue-print for solving the business problem on the infrastructure level. Application management teams should define the solution in terms of application architecture. The infrastructure planner and application managers should collaborate to address technical risk and anticipate future risks and requirements. Application architecture and infrustructure architecture must address services, service level matrices, the complexity of the solution, estimated time to market and provide a model of projected costs. A basic prototype or other form of "proof-of-concept" should be used in a Test Lab setting to evaluate the doability of the proposed solution.

At this stage, the deliverables are a Release Plan (RP), Application Architecture Specification (AAS), Assemble Infrastructure Plan Draft (AIPD), and Predictive Cost Model Document (PCMD), Functional Prototype (optional).

Implementation

In this phase product development is borken down into a series of iteration cycles. The length of the iteration cycle will depend on the complexity and scope of the product. It is recommended that the iteration cycle be between two and four weeks in length.

This strategy puts concrete deliverables in the hands of customers who will inevitably provide invaluable feedback. The result of this kind of iterative loop is a quantifiable reduction of risk.

The deliverables are Iteration Plans and Checkpoints.

Release

A product is expected to transition through multiple "minor releases" before a "major release". Minor releases should occur frequently (at the discretion of product management). The purpose of any release is to determine of a set of risks has been successfully eliminated. Major releases will generally evaluate a much larger set of risks than Minor releases and will ultimately determine the success or failure of the product. Each release must be accompanied by a Release Contract in order to define and hold accountable every party involved in the release. The Release Contract must be approved by each party involved before the Release Conract is executed.

All functionality deemed in "alpha" or "beta" stages should adhere to release procedures as they will ultimately face some or all clients. Monitoring utilities should be enabled on live systems, customer feedback forms should be integrated into the product along with automated critical error/crash reports if possible. Feedback and system logs are envaluable in qualifying product performance in "live" environments.

Deliverables for this stage are Release Contract, Product, Product Evaluation

Deployment

Test-driven development requires continuous integration of code written by the development teams. Integration may take on the form of code merges within a Code Versioning repository (CVS) followed by deployment to Testing or Staging servers in the Test Lab. A "Release" is merely a deployment to "Live" (client-facing) environment with the assumption that the release passed all testing in the Testing Lab under live conditions. Deployments to Testing environments should occur frequently (on a daily or even bi-daily basis) by developers acting individually or in teams. Focus must be on unit, functinoal, and stress testing which for most cases, can be automated by easily atainable tools and utilities (JUnit, Cactus, etc.).

Testing will provide insights into the problem domain and expose architectural weaknesses in the infrastructure and the application forcing the management teams to revisit the planning stages. All "bugs", suggestions, and issues must be submitted to a task management application (JIRA) and resolving the riskiest ones should be a priority while the problem area is still "fresh".

Deliverables for this stage are Regression Testing Reports (RTR) as well as tuned Application Architecture Specification (AAS), Assemble Infrastructure Plan Draft (AIPD), and Predictive Cost Model (PCMD) documents.

original: Azubuko Obele
contributions: Yuriy Krylov

Taking Baby Steps (part 2): Only one person reads my Blog and I've already won

2007-07-31T01:46:00.000-04:00

Overview
My last post entitled "Taking Baby Steps (part 1): Personal, Ad-hoc, KB", suggested that Knowledge Workers should embrace a Blog (at work) as a personal Knowledge Base. The focus was on the Network of One and some of the wins on a, facetiously, "selfish" level. Laying a foundation for productivity-focused collaboration is realizing that the "hidden hand" also works wonders in a collaborative setting.

In this post, I will talk about some ways in which this Network of One also benefits folks One Social Degree away -- even if it's just one other person. This is the Network of Two.

Who is One Social Degree Away?

People who directly depend on your work
People whose work you directly depend on
Your manager
Your intern
Your service team overseas
Your client

At work, our "social network" of peers is typically well established. We are hired into teams, we have colleagues, team-mates, customers. Someone depends on what you produce - these people will benefit from the knowledge you share.

Syndicate updates via RSS/Atom
Any good Blogging software already has syndication capabilities built in. Simply advertise the URL to your Blog's "feed". All you need is an RSS reader. Some come integrated with your email client, others are standalone or web-based. Your friendly, neighborhood IT department should have something to meet your needs.

But this is a post on the Network of Two. Your manager is, in fact, the first person to whom you should advertise your RSS feed. Your immediate manager will always be your #1 fan.

Managers love Workstreaming
Once your manager subscribes to your RSS Feed, and you make a selfish commitment to maintain your very own knowledge base, you will automagically keep your manager concurrent with the happenings in your daily work-life.

The Network of Two and effective Workstreaming will emerge when you begin to cater "some" posts to your immediate audience. Hint to your manager that something is especially important to her with Tags such as "important" or "for larry".

The key is to allow the Blog/KB to become part of your natural routine. There are no rules of how much to post or how often. Just keep things relevant.

Completing the Feedback Loop
You know you've established a successful Feedback Loop within your Network of Two when:

You find a "comment" on your Blog from your manager

I really want that first point to stand out - there are other indicators and emergent efficiencies when this Feedback Loop is completed:

Meetings between you and your manager are shorter and more to the point
You spend less time figuring out things you've forgotten
You manager seems more helpful and, in general, more knowledgeable about what you are working on
Sometimes the last point allows your manager to spot problems early and offer some very timely wisdom.

And so on...

Extra Brownie Points
The rarely seen but often sought after "Manager's Blog" where you get to leave comments.

Reverse Mentorship
I read my intern's blog every morning and I learn a book's worth every week. Just yesterday, I received a very in-depth refresher course in Java's SOAP API.

What about the team-mates?
My team works on many projects at the same time. I'm only a lead on one or two of them. This means that I need extra help staying up to speed on projects where I play a secondary or tertiary role. I read my peers' Weekly Update-tagged posts only. Good Blogging software will allow you to subscribe to a filtered subset of all the posts based on one or more Tags. How does my RSS reader know it's a Weekly Update? The Tag is "weekly".

For these secondary projects, reading "weekly" posts is enough for me to stay on track. This is especially helpful when I come back from vacation and dread opening my INBOX.

Non-urgent Information Only
Many folks try to misuse RSS by using it for Alerting purposes. This is not what the syndication medium is for. If you want to catch someone's attention because you require Immediate Feedback, use the phone, send an instant message, meet them at the Cooler.

RSS is best suited for Knowledge sharing that does not require immediate response. Your audience consumes the content at their own leisure, at their own pace. If you use RSS for anything else, it will very soon become as noisy and convoluted as email is today.

Final note of advice here -- turn desktop popups for RSS Updates off. Unless the Alerting mechanism is really smart, it will never know what is truly important to justify the time wasted recovering from the Interruption. I'm busy and need to focus, stop competing for my attention because my feed from pizza.com has an update.

Up Next, Too many Feedback Loops?
Every communication medium will be abused and misused. You may find yourself subscribed to too many feeds claiming importance. My next post will talk about cutting through noise with RSS and Tag-powered Dashboards.

Firefox EWG's first call is a success!

2007-07-25T16:12:00.000-04:00

Thanks to everyone who attended the first Enterprise Working Group for Firefox call. We're still waiting for a statistic on how many folks were on the call and on the irc channel -- I'd ballpark the figure to be somewhere in the mid 20s.

Special thanks to Mike Kaply for MCing the call and to JT Batson and Basil Hashem from Mozilla for providing insight and effectively validating this initiative.

Very Brief Summary
The theme of this meeting was "Experience". Folks on the call shared their personal experience with Firefox in an enterprise environment. There were clear areas of interest and overlap.

My main take-away has been this: It cannot be understated nor unappreciated that "Enterprises" do, in fact, share pain-points and challenges and therefore must come together to form a real, effective Community.

Some identified synergies
By no means a completed list, but here is what jumped out at me:

Packaging.

Story around MSIs and MSTs vs some open source formats. Most Enterprises are heavy Windows users. At what point does the lack of these hinder adoption?
What is feasible? What can Mozilla own and what can and should the Enterprise Community own?

Patch Management.

If an organization is not very Agile and agility assumes that not everything is perfect out of the box, is Mozilla's patch cycle too agile for "enterprises"?
How are others patching Firefox on desktops without having to uninstall and install the entire product?

Settings Management.

What are some trade-offs between GPO and Mission Control?
Not all settings are manageable.
What settings should be exposed by all extensions to enable pref-level lockdown?
Can we drive best practices for deploying plugins and extensions? There is very little documentation on where Plugins should go and how to configure in the registry.
How do we prevent some critical settings from being "tattooed" into prefs.js? I.e. mcontrol and user agent settings should never be written to prefs.js when in Enterprise mode.

User Profiles

How can profiles/certificates be migrated with minimum impact to the end-users?
Does having Firefox and IE share bookmarks help adoption? Can Firefox "piggy-back" on Favorites? How can it be done easily?

Follow-ups
Attendees were asked to contribute content to the http://wiki.mozilla.org/Enterprise wiki. Content will be refactored as we overflow. Mike and I will put up a page for each Meeting where we can post and track agendas, follow-ups etc and will work to keep content organized.

Up Next (August 8th)
Next call is scheduled for August 8th, same time, same station. Topic will be "Enterprise Wish List" and should be a fun, rowdy call!

Come one, come all. Help us spread the word.

To be politely blunt, we're committed to helping this community thrive. There will be wins. To my "enterprise" peers, you cannot afford to not have your interests represented - the potential for the Enterprise Web Browser as the Knowledge Worker's Killer App is too real.

Taking Baby Steps (part 1): Personal, Ad-hoc KB

2007-07-21T09:40:00.000-04:00

Overview
This collection of posts is part ideology and part methodology aimed at Knowledge Workers still struggling to embrace the Blog and Wiki whateveryoucallit. I don't blame them. The words "Blog", "Wiki", "Tag", and so on, meant very little to me as well until I put each of the technologies to a very specific use.

What started out as a system to manage developer teams overseas turned into a Pipeline for Knowledge Sharing within a Team.

To me, collaboration is a Bottom-to-Top story. It begins with a very selfish Network of One. And that's OK! If you can't prove value to yourself, how can you prove it to the guy sitting next to you at meetings?

Mental Filters
Like many Knowledge Workers, I suffer from information overload and a bad memory. First step is always admitting you have a problem, right? Now, I tend to ask myself two questions whenever I deal with information:

Is it useful to me now?
Might it be useful to me later?

If there's even a remote chance that I'm dealing with Useful Information, it needs to go into my Knowledge Base. This is my Mental Filter. All incoming information competing for my attention goes through this and other filters.

A Blog is a Personal, Ad-hoc Knowledge Base
It just so happens that the simplest and most complete Knowledge Base I know of is my Blog. It's mine. It's for me. I don't care about structure, colorful phrasings, or a full bibliography. I just need useful knowledge sans the BS. If I take the time out of my Very Busy Schedule to throw something into my Knowledge Base (KB), I owe it to no-one but myself to only post useful and Highly Relevant information.

I also haven't figured out how to not live in my INBOX so I want to be able to email my KB.

Side Note: But wait, why not store everything in email and search there? With Blogging, selfishness turns into something very useful for the rest of the Team. Email just doesn't have that kind of potential for collaboration.

Finally, I want control over the organization of my Knowledge Base but I don't have time to organize into pretty folders. I just want the information I need at my fingertips with minimum management. And while on the topic of being selfish, I want the search functionality to work for me; I want to help it help me. I want to be able to Tag my KB posts with words or phrases that serve as Keys to Knowledge in my head. It should be easy for me to share these Keys with the cyborg extension to my head that is my personal KB. The search functionality in my KB should pay special attention to these Tags a.k.a Keys. It's a matter of improving relevancy and hence my productivity.

A note about Privacy Concerns
Start with a Blog that your Firm provides for you. It should be internal and inaccessible from the outside world by the outside world. Don't worry about protecting your posts from the prying eyes of colleagues. Focus on yourself. Only your immediate network will ever care about what you have to say anyway. Post openly, but only post work-related information. Remember, you don't have the time to post on anything else.

What kinds of things should I post about?
It took me a bit of trial and error to figure out my Blogging sweet-spot. At first you'll post too much or too little. Remember, it's for you so figure out what works for you.

Some ideas on what you may want to track in your KB:

You figure out how to do something, save yourself brain space, write yourself a mini how-to
You solve a problem, post solution so you don't have to solve it again
Someone owes you a TPS report
You've identified follow-up items at your 3-hour meeting
You wish to condense your meeting to 15 minutes by posting an Agenda to your KB
Someone else posted something that may be useful to you later

Ans so on...

Conclusion
When picking out a KB starter-kit, be selfish. My recommendation is to go with a Blog. Blogs have many useful features; clearly I've only scratched the surface. But really, the other features will come in handy later. Here is what you should ask of your Personal, Ad-hoc Knowledge Base Blog:

Can you email it?
Can you tag posts?
Can you tag posts within your email?
Can you search it?
Are your search results influenced by the tags you assign to your posts?

Good news is most Blog implementations already do this. Your friendly, neighborhood IT department will help you set one up.

Up Next
In my next post, I will talk about how KB-directed Selfishness is, in fact, very useful to Team-mates.

Ant Build Script for Mozilla Extensions

2007-07-18T20:06:00.001-04:00

I play with Mozilla Extensions in EclipseIDE and generally like the Ant build system. Not an expect at Ant by any means so if anyone out there wants to make improvements to these, please share. The relative paths to directories are set in the build.properties file so that it shouldn't matter what folder layout one uses. If I make improvements to this over time, will post updates, feel free to drop feedback.

build.xml

<?xml version="1.0"?>

<project name="Firefox Extension Builder" basedir="." default="package">
 <property file="build.properties" />
 
 <target name="setup" description="create dir structure for project">
  <mkdir dir="${content.dir}"/>
  <mkdir dir="${skin.dir}"/>
  <mkdir dir="${install.dir}"/>
  <mkdir dir="${locale.dir}"/>
  <mkdir dir="${defaults.dir}"/>
 </target>
 <target name="clean" description="Delete previously generated jars">
  <delete file="${install.dir}/**" verbose="true"/>
 </target>
   <target name="createjar">
    <delete file="${install.dir}/${project.name}.jar" verbose="true" failonerror="false"/>
     <zip destfile="${install.dir}/${project.name}.jar" excludes="*CVS*/**">
      <zipfileset dir="."
           includes="${content.dir}/**, ${skin.dir}/**, ${locale.dir}/**"/>
     </zip>
   </target>

   <target name="createxpi" depends="gen_manifest,createjar">
     <zip destfile="${install.dir}/${project.name}.xpi">
        <zipfileset dir="${install.dir}" includes="${project.name}.jar" 
                  prefix="chrome" />
            <zipfileset dir="${install.dir}" includes="${manifest.src}"/>      
      <zipfileset dir="." includes="${install.src}" />
      
   </zip>
   </target>
   
   <target name="gen_manifest">
    <copy file="${manifest.src}" tofile="${install.dir}/${manifest.src}" overwrite="true"/>
    <replaceregexp file="${install.dir}/${manifest.src}" 
     match="^(content\s+\S*\s+)(\S*/)$"
     replace="\1jar:chrome/${project.name}.jar!/\2"
     flags="g" byline="true"/>
    <replaceregexp file="${install.dir}/${manifest.src}"
     match="^(skin|locale)(\s+\S*\s+\S*\s+)(.*/)$"
     replace="\1\2jar:chrome/${project.name}.jar!/\3"
     flags="g" byline="true"/>
   </target>
   <target name="package" depends="clean,createjar,gen_manifest,createxpi"/>       
</project>

build.properties

project.name=${your_project_name}
content.dir=chrome/content
skin.dir=chrome/skin
locale.dir=locale
defaults.dir=defaults
install.dir=install
manifest.src=chrome.manifest
install.src=install.rdf