RiskFactor

Growing as a Developer

David — Thu, 01 Oct 2009 08:00:00 -0600

I was reflecting recently on my own growth as a developer over the last several years. There are two factors in my own development that I identified as playing a significant and indispensible role.

Partners-In-Crime

I have been privileged over the last couple of years to work with other developers that have spurred me on to new heights in software development. There has been a mutual give and take of discoveries and lessons learned. There has even been a friendly sense of competition in challenging one another to keep learning and growing. Unfortunately two of the most influential developers during this time aren’t as big a part of my professional carrier as they once were. One has moved on to a new company and the other is in the process of transitioning to another company.

I can’t emphasize enough the importance of having these types of peers. More over, it is highly important that you and they see the process of learning and growing as something to be shared. We all know, or have known, those types of developers that, for one reason or another, lock themselves into a citadel of their own knowledge and refuse to help others grow and thereby restrict their own growth. I am opposed to this type of mentality and believe that we should all strive to challenge each other to grow and to help each other do so. It is one thing to tell another developer where she needs to grow, it is another to play an active role in helping them to grow.

Pages that Turned Me

In addition to my friends, there have been several books that opened whole new concepts and areas of growth for me. Below are four books that have enlightened, taught and challenged me. There have been others, but these were among the first that pointed me in a new direction and helped me to “turn over a new leaf” as a developer. I would encourage anyone that hasn’t discovered these books to seriously consider making them a part of your library.

Code Complete: A Practical Handbook of Software Construction
Author: Steve McConnell

Rapid Development: Taming Wild Software Schedules
Author: Steve McConnell

Refactoring: Improving the Design of Existing Code
Author: Martin Fowler

Design Patterns: Elements of Reusable Object-Oriented Software
Authors: Gamma, Helm, Johnson and Vlissides

Expression Encoder 3 Screen Capture Application

David — Tue, 22 Sep 2009 10:25:29 -0600

Lately I have been involved in a couple of projects that have kept me busy and not given me much time to work with Silverlight and WPF so I haven’t been keeping up on the progress of the Expression 3 products release. Yesterday I was browsing my MSDN subscription for a download and noticed that Expression Studio 3 RTM was on the site for download. What was even more interesting was that the full studio was available under my VS 2008 Professional MSDN subscription. Previously only Expression Blend and Expression Web were available. So, I immediately started the 252 MB download to check it out.

I haven’t had the opportunity to go through the whole Studio but one of the cool things I noticed right away is the new Expression Encoder 3 Screen Capture application.

Most of us have used screen capture tools and this particular application is very similar to others. It can capture the standard screen and mouse movements as well as web cam video and audio. What is unique is that you can then take the captured footage and directly import it into Expression Encoder with a single click. From inside Encoder you can then encode the video into a number of previously supported formats such as WMV, or into new formats such as H.264 including both Standard Def. and High Def. qualities. It also has preset encoding options that allow you to target: Silverlight (IIS Smooth Streaming, etc.), devices (Windows Mobile, Zune, Zune HD, XBOX 360, iPhone, etc.), and online services (YouTube HD/SD, Facebook, Vimeo HD). This is a cool little application and compliments the full Encoder 3 application very well.

Know Thyself; Know Thy Team

David — Thu, 06 Aug 2009 14:10:00 -0600

One of the most enjoyable aspects of being a Project Architect/Lead, and one which can sometimes be the source of frustration, is being part of a development team. Any developer that has been part of a team knows that the production of a quality piece of software is affected by numerous factors, not the least of which is team dynamics. Part of being a leader in a team is not only understanding yourself, but also understanding the people on your team and the overall personality and dynamics of the team given the current members.

One of the tools that has been significant in helping me to understand myself, my strengths and weaknesses, has been the Jung/Myers-Briggs personality assessment. (For those who have never heard of this before you can check it out here and take a quick online assessment hereto find out what your personality type is.) It has shed light on some of my own behaviors as well as helped me to identify those areas that I struggle with and why I struggle to change in those areas. As an INFP I have never felt a high level of excitement over administrative tasks. That does not mean that I can’t develop adequate administrative skills, it just means that I am not going to develop a sense of fulfillment for that type of work nor will it be something that energizes me. However, as an INFP I am a die hard idealist. I love to discuss, expound and implement best practices in my software, but have also had to learn to inject myself with a good dose of realism on certain projects.

Understanding the personality types is beneficial in team dynamics and is two fold. First you need to understand the personalities of each individual on your team. This is necessary so that you can better help them to develop in those areas where they are weak and also, to ensure that the majority of their time is spent on areas that are in alignment with their personality. This helps to ensure that they are energized by their work instead of drained by it. As a general rule you want to make sure that the members of your team are working about 60-70% of the time in positions or on tasks that line up with their personality type.

For example, you will find that there are some personality types that are less likely to deviate from previously used practices and tend to work within those practices with great satisfaction, efficiency and high productivity. This type of team member is a great “work horse” that can get a lot of work done as long as the parameters are defined for them and the direction is clear. On the other hand, this is generally not the type of personality that you want to put on a task that requires a high level of creativity and thinking outside of the box. Not that they can’t ever do that, but they will tend to not be as satisfied and energized by that work if it takes up the majority of their time.

Secondly, you not only need to understand the individual personalities on your team, but you also need to understand the overall personality of you team. If you have a large number of Introverts on your team then you may need to focus more explicitly on communication within your team and with the other stake holders on your project. If you have a high level of personality types with Judging as a strength you may find your team struggles to improvise under certain circumstances. Ideally the analysis of your team should help you to adjust the makeup of your team (if possible) so that it is well balanced.

With this in mind here are a couple of questions to think about:

Does a persons personality type affect their predisposition to a particular methodology for the Software Development Lifecycle?
How does the overall personality of your team affect your teams success with a given SDL methodology?

Managing Session Variables in ASP.NET using a Proxy – Part 2

David — Wed, 05 Aug 2009 15:54:00 -0600

In my last post I gave an example of using the Proxy Design Pattern to manage your ASP.NET Session. In this post I wanted to refine that proxy class through some refactoring and add some additional functionality to it that remove Session variables and also allow us to use the proxy to clear or abandon the Session as a whole. We will also create a mechanism for grouping Session variables into related objects in the SessionProxy.

First I want to add a private property that will allow me to eliminate some of the verbosity in my code. I’ll add a private static property that encapsulates the current HTTPSessionState object. We can then use that property to refactor our other properties so they are more readable.

   1: private static HttpSessionState Session { get { return HttpContext.Current.Session; } }

Next we’ll add some code into our properties that will check for the value being set and remove the Session variable from the Session object if necessary. As an example I’ll use a new Property of type String.

   1: public static String CategoryName

   2: {

   3:    get

   4:    {

   5:       if (Session[CATEGORYNAME] == null) { return String.Empty; }

   6:       return (String)Session[CATEGORYNAME];

   7:    }

8:

   9:    set

  10:    {

  11:       if (String.IsNullOrEmpty(value)) { Session.Remove(CATEGORYNAME); }

  12:       else { Session[CATEGORYNAME] = value; }

  13:    }

  14: }

Now I want to add a few methods to allow me to use the SessionProxy to Clear the current Session or Abandon it.

   1: #region Methods

2:

   3: public static void Clear() { Session.Clear(); }

4:

   5: public static void Abandon() { Session.Abandon(); }

6:

   7: #endregion

At this point I feel that I have a pretty good proxy class that allows me to leverage my ASP.NET Session in a strongly type manner and to easily see what I am storing in the Session and what their types are.

However, in using this solution in a production application I have found that my list of properties has grown longer than I would like. There were close to two dozen at last count and all the Session variables have not been migrated to use the proxy. I found myself increasingly tired of seeing all those properties each time I accessed the class. On top of that some of the names were getting rather long in an effort to give them meaningful names. To resolve this I implemented several properties on the SessionProxy that were child proxy objects. To make things a bit easier I created a base class called SessionProxyChildProxyBase. Here’s the code in full for that base class.

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Web;

   5: using System.Web.SessionState;

6:

   7: public abstract class SessionProxyChildProxyBase

   8: {

9:

  10:   #region Properties

11:

  12:   protected HttpSessionState Session { get { return HttpContext.Current.Session; } }

13:

  14:   #endregion

15:

  16: }

You will note a few points on this class. Unlike the SessionProxy class the SessionProxyChildProxyBase class is an abstract class. We don’t want to allow others to implement this base class outside of our library so that the SessionProxy class now becomes a proxy for this class as well as for the ASP.NET Session. It also contains a protected Session property that will facilitate a decrease in code verbosity.

Now we will leverage this base class and create derived classes that will contain related properties. In your application you may provide a central location for entering search criteria but you pass those criteria via the Session to a page that actually displays the search results. Let’s create a child proxy class to organize the various values being passed.

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Web;

5:

   6: public class SearchSessionProxy: SessionProxyChildProxyBase

   7: {

8:

   9:   #region Fields

10:

  11:   private const String SEARCHTEXT = "SearchText";

  12:   private const String SEARCHTYPENAME = "SearchTypeName";

13:

  14:   #endregion

15:

  16:   #region Properties

17:

  18:   public String Text

  19:   {

  20:      get

  21:      {

  22:         if (Session[SEARCHTEXT] == null) { return String.Empty; }

  23:         return (String)Session[SEARCHTEXT];

  24:      }

25:

  26:      set

  27:      {

  28:         if (String.IsNullOrEmpty(value)) { Session.Remove(SEARCHTEXT); }

  29:         else { Session[SEARCHTEXT] = value; }

  30:      }

  31:   }

32:

  33:   public String TypeName

  34:   {

  35:      get

  36:      {

  37:         if (Session[SEARCHTYPENAME] == null) { return String.Empty; }

  38:         return (String)Session[SEARCHTYPENAME];

  39:      }

40:

  41:      set

  42:      {

  43:         if (String.IsNullOrEmpty(value)) { Session.Remove(SEARCHTYPENAME); }

  44:         else { Session[SEARCHTYPENAME] = value; }

  45:      }

  46:   }

47:

  48:   #endregion

49:

  50:   #region Constructors

51:

  52:   internal SearchSessionProxy() { }

53:

  54:   #endregion

55:

  56: }

Now we need to add some code to our SessionProxy class to leverage this new class. The first task is to add a private static field of type SearchSessionProxy.

   1: #region Fields

2:

   3: private static SearchSessionProxy _searchProxy = new SearchSessionProxy();

4:

   5: #endregion

Next we will create the property to access the field.

   1: public static SearchSessionProxy Search { get { return _searchProxy; } }

And that’s it! Now we call utilize our SessionProxy with our new child proxy classes for organization and grouping so that we can doing something like this in our web app code…

   1: public void DoSomething()

   2: {

   3:  SessionProxy.Search.Text = "Search Text entered by user";

   4:  SessionProxy.Search.TypeName = "Product Search";

   5:  SessionProxy.ProductID = 0;

   6:  Response.Redirect("SearchResults.aspx");

   7: }

Managing Session Variables in ASP.NET using a Proxy

David — Tue, 21 Jul 2009 14:51:00 -0600

Every developer who has ever worked with ASP.NET in a large solution knows how quickly Session variables can get out of control. From the lack of strongly typed references to the potential misspellings of the variable names, the problems are always with us. The good news is that there is a better way to handle objects in the Session. The key is to develop a proxy class that will provide a set of strongly typed properties to store and retrieve objects in the HTTPSessionState object.

The Gang of Four defines the Proxy Structural Pattern as an object that serves to “Provide a surrogate or placeholder for another object to control access to it.” A proxy is a fantastic way to provide abstraction in any application and will allow us to create a method for leveraging an ASP.NET Session object in a powerful way.

To begin with let’s create a static class (or NotInheritable in VB.NET) called SessionProxy. The code will look something like this:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Web;

5:

   6: public static class SessionProxy

   7:    {

8:

   9:       #region Properties

10:

  11:       public static int OrderID {

  12:          get

  13:          {

  14:             return (int)HttpContext.Current.Session["OrderID"];

  15:          }

16:

  17:          set

  18:          {

  19:             HttpContext.Current.Session["OrderID"] = value;

  20:          }

  21:       }

22:

  23:       public static int ProductID

  24:       {

  25:          get

  26:          {

  27:             return (int)HttpContext.Current.Session["ProductID"];

  28:          }

29:

  30:          set

  31:          {

  32:             HttpContext.Current.Session["ProductID"] = value;

  33:          }

  34:       }

35:

  36:       #endregion

37:

  38:    }

You will notice in this initial code that we are typing the Session variable keys multiple times in each property definition. Although this is a workable solution we still open ourselves up to the possibility of mis-spelling the two instances of the key. So, let’s refactor our class a bit…

   1: public static class SessionProxy

   2:    {

   3:       #region Constants

4:

   5:       private const string ORDERID = "OrderID";

   6:       private const string PRODUCTID = "ProductID";

7:

   8:       #endregion

9:

  10:       #region Properties

11:

  12:       public static int OrderID {

  13:          get

  14:          {

  15:             return (int)HttpContext.Current.Session[ORDERID];

  16:          }

17:

  18:          set

  19:          {

  20:             HttpContext.Current.Session[ORDERID] = value;

  21:          }

  22:       }

23:

  24:       public int ProductID

  25:       {

  26:          get

  27:          {

  28:             return (int)HttpContext.Current.Session[PRODUCTID];

  29:          }

30:

  31:          set

  32:          {

  33:             HttpContext.Current.Session[PRODUCTID] = value;

  34:          }

  35:       }

36:

  37:       #endregion

38:

  39:    }

To utilize this in your code simply add a reference to the namespace where the SessionProxy exists and get or set the property through the class (ie. SessionProxy.ProductID = 123;).

Now we have a method for accessing our Session in a strongly typed manner and we are also able to see exactly what variable we have defined in our ASP.NET application by simply looking at the class definition of our SessionProxy.

Another advantage of using a proxy class like this is that it allows you to abstract your storage method as well. If you want to use SQL Server Session or use a shared Session technology across multiple servers, all you need to do is change the property getter and setter logic and the rest of your application remains completely unchanged.

In Part 2 we will explore some enhancements to the SessionProxy.

New Collaboration Tool

David — Fri, 29 May 2009 17:47:00 -0600

I have worked at several companies now that have used a number of different tools for online demos and collaboration such as WebEx and GoToMeeting. Microsoft has now introduced a new product that provides the same functionality but is completely free! The new product is called Microsoft SharedView.

SharedView, like the other brand collaboration tools, requires a small download and installation. When you open the program it places a menu bar at the top of the desktop that provides access to the application features. This new tools allows up to 15 members in a given session and provides for application specific sharing or full screen sharing. The session host must have a valid Windows Live Account (Hotmail and Microsoft Passport accounts work as well) to start a session. However, the other participants do not need to have an account. Once the session is started the other participants simply enter the user id of the session host and the password for the session that is generated when the session is initiated.

One of the more interesting features the SharedView provides is the presence of multiple mouse cursors on the screen labeled with the name of the participant that is represents. This is a great feature that allows the other users to be able to point to areas on the screen without having full control of the shared application.

If your looking for a great free product for real-time collaboration I really encourage you to check out Microsoft SharedView.

Accidental Singletons in Collection-Type Dependency Property

David — Thu, 26 Mar 2009 12:00:00 -0600

Dependency Properties are a unique and powerful feature of WPF/Silverlight though they are normally transparent to you and you will, for the most part, not worry about them. However, there are times when creating a Custom Dependency property will be the precise solution to your problem. Sometimes you will need to create a dependency property that is a collection-type. Now there is a very important point that you need to watch when creating a dependency property of this type, and that is the unintended creation of a singleton value.

Let’s see how this works and how you can resolve the issue.

(Insert here the obligatory creation of a temporary Silverlight application.)

After creating my temp application I created two classes. The first is a person class. The second is a Family classes that exposes a Members property that is backed by a dependency property and is of the type List<Person>.

   1:  using System;

   2:  using System.Net;

   3:  using System.Windows;

   4:  using System.Windows.Controls;

   5:  using System.Windows.Documents;

   6:  using System.Windows.Ink;

   7:  using System.Windows.Input;

   8:  using System.Windows.Media;

   9:  using System.Windows.Media.Animation;

  10:  using System.Windows.Shapes;

  11:  using System.Collections.ObjectModel;

  12:  using System.Collections.Generic;

13:

  14:  namespace SilverlightApplication1

  15:  {

  16:      public class Family    : DependencyObject

  17:      {

  18:          public static readonly DependencyProperty MembersProperty = DependencyProperty.Register(

  19:              "Bars",

  20:              typeof(List<Person>),

  21:              typeof(Family),

  22:              new PropertyMetadata(new List<Person>()));

23:

  24:          #region Properties

25:

  26:          public List<Person> Members

  27:          {

  28:              get { return (List<Person>)GetValue(MembersProperty); }

  29:              set { SetValue(MembersProperty, value); }

  30:          }

31:

  32:          #endregion

33:

  34:      }

35:

  36:      public class Person

  37:      {

  38:          #region Properties

39:

  40:          public string FirstName { get; set; }

  41:          public string LastName { get; set; }

42:

  43:          #endregion

44:

  45:          #region Constructors

46:

  47:          public Person(string firstName, string lastName)

  48:          {

  49:              FirstName = firstName;

  50:              LastName = lastName;

  51:          }

52:

  53:          #endregion

  54:      }

  55:  }

In the application I created a simple method that creates two family objects and adds 3 members to the first and 2 members to the second. I then populate two variables with the corresponding Count from each of the Member property lists like so.

   1:  private void Button_Click(object sender, RoutedEventArgs e)

   2:  {

   3:      Family fam1 = new Family();

4:

   5:      fam1.Members.Add(new Person("David", "Risko"));

   6:      fam1.Members.Add(new Person("Wife", "Risko"));

   7:      fam1.Members.Add(new Person("Kid1", "Risko"));

8:

   9:      Family fam2 = new Family();

10:

  11:      fam2.Members.Add(new Person("John", "Doe"));

  12:      fam2.Members.Add(new Person("Jane", "Doe"));

13:

  14:      int fam1Count = fam1.Members.Count();

  15:      int fam2Count = fam2.Members.Count();

  16:  }

After placing a breakpoint at line 16 I investigated our two count variables. As you can see from the screenshot below we get an unexpected result where both Family objects show that they have 5 members each. Our code clearly adds 3 members to the first family and 2 to the second, so how is this happening?

The key to this is that we have defined a default value for our dependency property in the PropertyMetadata object when we called the Register method (line 22 in first code block). Our Member list is a reference type and so therefore the default value set in the PropertyMetadata is not a default value per Family instance but rather is is the default value for all instances of our Family. This is not the functionality that we are going to want in the vast majority of situations. We need an instance specific list backing our Members property and fortunately there is a straight forward solution. The key is to set your property to a new instance of its type in your constructor. Here is the new code for my Family class constructor that accomplishes this.

   1:  #region Constructors

2:

   3:  public Family() : base()

   4:  {

   5:      Members = new List<Person>();

   6:  }

7:

   8:  #endregion

Now when we run our application we get the following values in our count variables:

As you can see by simply re-initializing our dependency property value in our constructor we get the per instance functionality that we want and need.

Now when your out creating those custom dependency properties for collection-typed values you won’t get caught off guard.

NOTE: After typing this post I found the reference documentation on MSDN that actually covers this from a WPF perspective. The resolution in WPF is slightly different but still applicable.

The Shadow Knows! – The finer Nuisances of the VisualBasic.NET Shadows Keyword

David — Mon, 16 Mar 2009 15:22:00 -0600

I suspect that most people don’t often use the Shadows keyword. I happened to be using it to develop a custom control because the base class I was inheriting from does not declare one of its properties as Overridable. My control was inheriting from a StackPanel in Silverlight. I wanted to limit the type of controls that could be placed inside of my control so I shadowed the StackPanel.Children property, which is of type List(Of UIElement), with a Children property of type List(Of CustomType).

Initially that seemed to work. It compiled without error or warning so I thought I was good to go. Then the UI came up and I realized that things were not what they seemed to be. The objects that I defined in my XAML for test were showing up, but none of the objects I added programmatically were. Further more, the collection that was behind my custom property only contained the objects I added programmatically while the property on my StackPanel base contained the items I had defined in XAML. WHAT?! How is that?

The difference is in how Shadows works and how the Silverlight runtime was viewing my custom type. When you shadow a property/method, the original property/method is hidden when your object is viewed as your custom type. However, if your object, which is of your custom type, is cast to the type of the base class then the base class property becomes visible and is the one that gets accessed. Let me explain with an example.

I have created three classes. Class A is the base class which B derives from A, and class C derives from class B. Like so…

Public Class A
    ReadOnly Property FirstName() As String
        Get
            Return "A"
        End Get
    End Property

    Overridable ReadOnly Property Lastname() As String
        Get
            Return "1"
        End Get
    End Property
End Class

Public Class B
    Inherits A

    Shadows ReadOnly Property FirstName() As String
        Get
            Return "B"
        End Get
    End Property

    Overrides ReadOnly Property Lastname() As String
        Get
            Return "2"
        End Get
    End Property
End Class

Public Class C
    Inherits B

    ReadOnly Property FirstName() As String
        Get
            Return "C"
        End Get
    End Property

    Overrides ReadOnly Property Lastname() As String
        Get
            Return "3"
        End Get
    End Property
End Class

You will notice that the Firstname property on Class A is not declared as Overridable. This means that to replace it’s functionality I must declare it as Shadows in my derived class B. I have purposefully left out the Shadows keyword in Class C to show that VisualBasic.NET implicitly Shadows any properties/methods in the derived class if the name matches the name of a property/method in the base class.

Now, here is a quick code snippet for a console app that will demonstrate this nuisance of Shadowing.

Sub Main()
    Dim cClass As New C

    Console.WriteLine("Typed as C: FirstName {0}, Lastname {1}", cClass.FirstName, cClass.Lastname)
    'Typed as C: FirstName C, Lastname 3

    Console.WriteLine("Typed as B: FirstName {0}, Lastname {1}", CType(cClass, B).FirstName, _
                      CType(cClass, B).Lastname)
    'Typed as B: FirstName B, Lastname 3

    Console.WriteLine("Typed as A: FirstName {0}, Lastname {1}", CType(cClass, A).FirstName, _
                      CType(cClass, A).Lastname)
    'Typed as A: FirstName A, Lastname 3

    Console.ReadKey()

End Sub

Notice how the value that is returned for Firstname is the value corresponding to the type by which my object is being accessed. This correlates to my Silverlight example. When I was adding items to my custom object programatically I was referencing it as the same type of which it is. However, when the Silverlight run time was building the UIElement tree it was accessing my item as its base type so the items were added to the base type property, not my custom Shadows property.

So, when it comes to Shadowing, you will want to be aware that referencing your classes as the base type will expose the base types functionality and not the Shadowed functionality.

Fortunately Overrides works differently so that the functionality declared as Overrides on the most derived class will always be run and not the functionality of the base class(es). To verify this try removing the Overrides keyword from Class C. Now the functionality that is declared as Overrides in Class B will always be accessed for the Lastname property. You should get the following output to your console.

Typed as C: FirstName C, Lastname 3
Typed as B: FirstName B, Lastname 2
Typed as A: FirstName A, Lastname 2

Hopefully you have found this quick excursion into the finer points of Shadowing helpful and the next time you use Shadows you’ll know what to expect from your derived classes.

Focus on LOB’s in Silverlight 3

David — Thu, 12 Mar 2009 10:07:00 -0600

I know there are developers out there looking at Silverlight thinking that it’s just another media delivery platform and that Microsoft is just trying to gain market share over Adobe in this area. However, the truth, I am convinced, is much different. The overlooked aspect of Silverlight that will make the biggest impact in the Rich Internet Application space is the support for Line-of-Business applications to be developed in Silverlight.

This past Monday The Knowledge Chamber posted an interview with Brad Abrams on Channel 9 in which Brad gives us a few teasers about the LOB support being added to Silverlight 3.0. In the interview Brad shows us the new project template for a Silverlight project that gives a default design to your Silverlight application and that design will apparently be swappable for other default designs. There is also a short preview of new datagrid features and a new details view control. He also highlights the new “Deep Link” feature that allows you to access specific places in your Silverlight application via a URI. The only down part is that we have to wait until MIX09 to see the full feature set, but luckily that’s only another week!

No Custom Dependency Property Value Inheritance in Silverlight 2

David — Thu, 05 Mar 2009 11:43:00 -0600

So I have this cool custom control I am working on in SL2. I was hoping to utilize a custom dependency property that could inherit it’s value from a property on a parent object. But alas, Microsoft has not provided an easy way to implement custom dependency property value inheritance per this post. It appears that they created a select few dependency properties that would do this, but due to performance issues they haven’t opened this up to the rest of us yet.