Gmail Priority Inbox

1. Important and Unread  or
   
2. Starred  or
   
3. Everything Else
   

With the release of Microsoft Codename "Dallas" CTP3 and the features announced in the previous post, it became easier to add support for Dallas to Sesame Data Browser.
The new version of Sesame published today allows you to browse Dallas datasets, as demonstrated below.

Creating a connection to a Dallas dataset in Sesame is easy. You just need a dataset URL and an account key.

The Dallas portal

In order to get an account key and URLs, you need to visit https://www.sqlazureservices.com and sign in with a Windows Live ID. You'll then be able to subscribe to datasets, such as AP Online (Associated Press) or business information from InfoGroup:

Note: Only CTP3 services are supported in Sesame.

Once you have a subscription, you can visit its preview page. This is where you'll find the URL you'll use in Sesame.
Here is for example the page for AP Online:

The URL for AP Online is highlighted in blue on the above picture.

Your account key is available on the "Account keys" page:

Dallas in Sesame

Now that you have an account key and a URL, you can create an OData connection in Sesame:

Here is the result for AP Online if you click on GetBreakingNewsCategories:

Copy a category ID and click on GetBreakingNewsContentByCategory.
Paste the category ID in categoryId and type 5 for count:

After clicking on Open, you'll get data in a grid, as usual:

You can also locate the news items on a map:

Known bugs

• A bug in Dallas CTP3 prevents the "Load more" button to work correctly in all cases.
• Dallas CTP3 does not support all filter operations. Namely, the EndsWith, StartsWith, Contains, DoesNotContain and IsContainedIn don' work with Dallas datasets.

Please give this new version a try. As always, your feedback and suggestions are welcome!

If you’re an avid reader of this blog, you probably now that I’m quite a big fan of the jQuery Javascript library, especially in combination with SharePoint sites. For a while I’ve been trying to find a mechanism to deploy jQuery and add a reference to it on all SharePoint pages of a site, by just using a Sandboxed Solution. The first part, deploying the jQuery file, is really easy; this can be done in a Module in a SharePoint project. The second part was more of a challenge; making sure the jQuery file got referenced in all pages of a SharePoint site. My initial thought was to do this by using the AdditionalPageHead Delegate control, but it’s not possible in a Sandboxed Solution (you need to deploy the .ASCX to the SharePoint root). My second thought was to use the new ScriptSrc attribute you can use in a CustomAction (I wrote about this attribute some time ago). But initially I was under the impression that the ScriptSrc attribute could only target Javascript files loaded from the SharePoint Root (the \LAYOUTS) folder, resulting in a no-go for a Sandboxed Solution as well. Daniel McPherson stumbled upon this issue as well, but neatly solved it using Javascript to add the reference dynamically.

But apparently you can make use of the ScriptSrc attribute to reference files from the Virtual File System (e.g. a Document Library in a site) as well! (thank you Frederic Dobon for mentioning this!). The trick is to use the ~SiteCollection prefix in the ScriptSrc attribute, for example:

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction
    ScriptSrc="~SiteCollection/SiteAssets/jquery-1.4.2.min.js"
    Location="ScriptLink"
    Sequence="10">
  </CustomAction>
</Elements>

It’s that easy! For your convenience I’ve uploaded the source code and the resulting SharePoint Solution (WSP file) to CodePlex.

I was just looking into the whole topic of drawing something on screen in a .NET WinForms application, so that it appears in the “correct” size. I found a number of issues around the handling of screen resolution and DPI, and in order to remember what’s what, and perhaps help somebody with the same problems, I thought I’d write it all down.

Some definitions

For a start, what does DPI really mean? It is often confused with “resolution". That is of course not wrong, but still very confusing. The term “resolution” is usually associated with displays – or perhaps that’s just my understanding. But when I hear somebody talking about resolution, I expect to hear things like 1024x768, and I’m sure I’m not alone. This kind of resolution information defines the total number of pixels that can be displayed.

Resolution alone doesn’t tell me everything there is to know about how a picture is going to look when displayed. The reason is that there’s a second factor that’s also important: the size of the display area. On a 15 inch screen, 1024x768 used to look okay. On your 21 inch flat screen it’s probably not so great.

That’s where DPI comes into play. It means “dots per inch", and that’s what it defines: the number of pixels an output device can render per inch of physical real estate.

For example, my old Dell 2001 FP is a 20 inch screen. That’s of course its diagonal, the size of the visual area is 16x12 inches (I’m surprised to find that this means exactly a 20 inch diagonal - well done, Dell!). It has a native resolution of 1600x1200 pixels. Easy maths - that’s 100 DPI!

On the other hand, I’m now using two 28 inch screens at a resolution of 1920x1200. Their size is 23.39x14.57 inches. DPI in horizontal direction is 82.1, in vertical direction it’s 82.4. With a large screen like this, DPI tends to be much lower because resolution isn’t keeping up well these days with the growth of screen sizes. It is also interesting that the two values I calculated aren’t identical - the difference seems large enough to think that it’s not down to measuring errors. Of course this is perfectly well possible, because DPI values in X and Y directions would only be identical if the pixels on the device were perfectly square.

Why is DPI relevant?

So why bother knowing these precise values for DPI? Well, it’s simple: because unless you know these values, you can’t predict how large something is going to appear when displayed. On printers, for example, knowing the DPI “resolution” of the output is very important. If you print a line that’s defined to be an inch long in your DTP application, you expect it to be an inch long when it comes out of the printer.

Although it surprises some people, the same is true for displaying something on screen. An application should be able to display a document on screen in such a way that an element which is going to be an inch long on printed paper is also an inch long on screen. This is easily possible when taking DPI into account, and entirely impossible when ignoring it.

Just in case you still think that’s a weird idea – think about it. When displaying a simple UI element, like a button, or perhaps a piece of text. Is it more useful to configure the button to be 80 pixels wide or 2cm? Does a text height of 10 pixels (I’m talking about labels or the like) give a better result or rather 4mm? In conjunction with text there are other measurements like pt and similar, which confuse things further. The point is, without taking the actual screen DPI values into account, you just don’t know what size something is going to have when the user sees it.

Of course some people realized the importance of DPI a long long time ago. In conjunction with computer displays, the standards DDC and EDID allow your computer to receive information about its size directly from your screen, which of course allows the computer to calculate the DPI values depending on the current resolution.

So what’s wrong in Windows?

There are several things that go wrong in Windows. For a start, it doesn’t seem that display drivers typically evaluate the EDID information to find out about DPI values automatically. I’m not an expert on this level, but I guess it would theoretically possible to do this on the driver level, and maybe there’s even some influence over the actual Windows DPI configuration that the driver has, but which is not passed on to the end user of the system. Maybe some graphics drivers do something in this regard, I don’t know.

It doesn’t matter all that much though, because Windows has always (largely) ignored or misinterpreted DPI for its own rendering of its UI. Very recently things are starting to change a bit with the introduction of vector based graphics through WPF and Silverlight, but of course it’s going to take ages until things change for the majority of applications that make up the OS, as well as 3rd party apps.

There are a few places where Windows takes DPI into account to some extent. For one thing, there’s some sort of scaling of UI elements going on, which usually results in rather crazy looking layouts. I don’t know anybody who really understands exactly what’s going on there, and I’ve never found it relevant enough to look into this and understand the details. There’s one other thing though, which most people have observed at one point or another: the “large fonts” setting in Windows.

I seem to remember that traditionally you could only choose between “normal” and “large” fonts. These days, i.e. in Windows 7, there’s a dialog that lets you select a “percentage of normal size” for your font display. So far, so good – this is of course a valuable feature to have.

If only they did it right…. let’s think about it. As I said above, knowing about DPI allows me to render a piece of text in such a way that it appears exactly 8mm high on screen. For example. If I want that piece of text scaled by 25%, I’ll render it to appear at 1cm height on screen. Again, knowing my DPI makes it possible, and if I can see 1cm high text better, that’s great.

On the other hand, what MS does defies any logic I can come up with (having accepted long ago that there are always several different kinds): they go and change the DPI value for the display depending on the “font size” setting. They just claim that my display has a DPI value different from what it really has. Wow.

As a side note

They don’t even get it right! Check out these two screen shots (from Windows 7, in spite of the appearance):

Now, as you can see I’m asked to enter the “percentage of normal size". I haven’t measured precisely, but I can believe that in the second shot, the height of the text is roughly twice that of the first shot, so the scaling of the font itself may be correct. But, tell me: how does that relate to the information that says “… at 192 pixels per inch"?

Logically, I can see two different scenarios. Number one, I have an element that is, say, 100 pixels wide. When displaying it at a DPI of 96, it would be just over an inch wide. At a DPI of 192, it would be just over half an inch wide. The higher the DPI, the smaller the object, if it has a fixed width in pixels.

Number two, I have an element whose size is not described in device pixels, but rather in a “real world” measurement, like inches or centimeters. If I have an element that is one inch wide, then I’d have to draw it over 96 pixels at 96 DPI and over 192 pixels at 192 DPI. Right? Right.

How MS manage to claim that the size of 9pt Segoe UI grows while the “fake DPI” grows as well, is beyond me.

Oh, and the “point” they are referring to? That’s a real-world measurement, called Point. According to its modern definition it measures 0.3527mm. Go figure.

Moving on – so why might they choose an approach of scaling by DPI? At a glance it seems like this might be a good idea if the objective is to scale your entire UI at once. By claiming to have a DPI that’s only half as large as the one I really have I would effectively double the size of everything on screen.

I think this would look crazy, rather like one of those magnifying glass implementations in pixel based drawing programs. I also think it also doesn’t make all that much sense for a computer UI – after all, there are many elements of varying importance on screen, and while I may want some of them to be larger so I can see them better, that doesn’t apply to every separator line and similar graphical gimmick. I’m almost sure MS don’t do this either.

… and there’s more

Okay, so it appears that Windows has at least some semblance of an understanding of DPI internally, regardless of the funny ideas with font sizes and large vs small DPI values. One minor issue, comparatively speaking, is the fact that you can only configure one DPI value, while it seems obvious that there should be two, one for the horizontal and one for the vertical direction. Well, I’m calling it minor… I’m sure it can be a rather big issue when carefully designing documents for large print output on your high res display while using a compromise DPI value that’s the same for X and Y.

More important is something else though: Windows enforces a particular range of DPI values. The 100% item in the dialogs shown above is the minimum value you can enter. Remember my 28 inch screens I described above? They have a DPI of 82. It’s impossible to configure Windows to this value. Why? Brilliant, just brilliant.

and some unknowns

I honestly don’t have a clue what the “Use Windows XP style DPI scaling” checkbox is for in the dialogs. I can’t use it either, it just goes on and off on its own.

Something for developers

If you’re a developer, there’s not too much you can do about the OS’s non-grasp of DPI information, but unfortunately you’re the one who gets criticized by customers if your display looks funny. Whatever use it is, there is some at least some functionality in Windows that lets you query DPI information to the extent that the OS is aware of it.

Generally this is quite simple and it’s been supported by Windows API calls forever. There’s a helpful function called GetDeviceCaps that you can call with a device context handle and a constant value called either LOGPIXELSX or LOGPIXELSY (hey, finally separate values! where should they come from at this point…?) in order to retrieve DPI info. Of course there’s a lot to do wrong when using Windows API functions – here’s an example, with the caveat that I’m not checking for errors from the API functions like I should. Oh, and I’m abusing Size as a container for the value pair. Well, if you just copy&paste, that’s your own fault :-)

[DllImport("user32.dll", SetLastError = true)]
public static extern bool SetProcessDPIAware( );

[DllImport("gdi32.dll")]
public static extern int GetDeviceCaps(IntPtr hdc, int nIndex);

[DllImport("user32.dll", SetLastError = true)]
public static extern IntPtr GetDC(IntPtr hWnd);

[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);

public static Size GetScreenDPI( ) {
  // no error checking here - being lazy
  var dc = GetDC(IntPtr.Zero);
  try {
    return new Size(
      GetDeviceCaps(dc, (int) DeviceCap.LOGPIXELSX),
      GetDeviceCaps(dc, (int) DeviceCap.LOGPIXELSY));
  }
  finally {
    ReleaseDC(IntPtr.Zero, dc);
  }
}

The pinvoke definitions are courtesy pinvoke.net.

Oh, and I found one thing that a lot of blog posts showed “wrong": they call CreateDC and DeleteDC instead of GetDC and ReleaseDC. My example simply retrieves the device context that already exists for the desktop, instead of creating a new one. I believe that should be much more efficient. Some other examples I found also leave out the bit with LOGPIXELSY – not something I would do. Can’t be that lazy.

Now, if you try this code, you may be a bit surprised to find that you don’t seem to get actual DPI information back. There’s a reason for that: MS think you’re going to do no good with it, and therefore they don’t give it to you unless you prove that you’re in fact clever enough. That means you need to call that function at the top of the example, SetProcessDPIAware, during your application initialization – otherwise GetDeviceCaps will just not tell you what the real values are. Great, eh?

Note: MSDN suggests you don’t use SetProcessDPIAware directly, but instead add an entry to your application manifest. See here.

Graphics != Graphics

Finally, I found a lot of blog posts that suggest you could retrieve DPI information from instances of the .NET Graphics class. This is true, and while I haven’t tried it now to confirm, I expect it will return the same values as the Windows API functions above. But there’s one important thing that the blog posts I’m talking about don’t usually stress: make sure you know where that Graphics instance comes from!

Think about it: why would the Graphics object have DPI information if it was always the same? No, the reason it has that information is because it depends on the graphics context the object represents. If you haven’t created a Graphics instance yourself, don’t assume what its resolution is. It might represent an image with whatever resolution, or perhaps a printer object with a very high DPI.

If you want to use Graphics for the purpose of retrieving DPI info, make sure you hold an instance that refers to an on-screen drawing context. And perhaps consider not using it at all – yes, it’s convenient, but it’s got a lot of overhead compared to simple API calls like the above.

As a final note

I’m not an expert in typography, and I’m describing everything in this post as logic seems to dictate, and according to my knowledge. I’m sure I’ve got at least one thing wrong, and if you know what it is, please let me know and I’ll fix it.

Exam Tips

Here’s a rundown of my best practice tips when sitting the Microsoft SharePoint 2010 Exams. Hopefully there’s something here for everyone, whether you’re a SharePoint Administrator (70-667, 70-668), or a SharePoint Developer (70-573 and 70-576) – or just preparing for Microsoft Exams in general.

Before we start our list of practical exam tips, I’m going to give you an extra tip for free:

Read more on Top Tips for Passing SharePoint Exams 70-667, 70-668, 70-573 and 70-576…

• Bookmark on Delicious
• Digg this post
• Recommend on Facebook
• Share on Linkedin
• share via Reddit
• Share with Stumblers
• Tumblr it
• Tweet about it
• Subscribe to the comments on this post
• Tell a friend

Technorati Tags: 70-563, 70-576, 70-667, 70-668, Exams, MCP, SharePoint 2010, Tips, Training

Ricapitolando:

• Lo stream era effettivamente h264, ma VLC (1.1.14 per Windows) non be ha proprio voluto sapere di visualizzarlo; in compenso sull’iPhone si vedeva benissimo quindi ho seguito così l’evento
• Ho fatto benissimo ad attendere la presentazione della nuova versione di Apple TV, così ora sarò ancora più sicuro nell’acquistare il WD Live HD <g> Peccato, se a quel prezzo e con quel fattore di forma avesse supportato almeno DLNA ci avrei potuto fare un pensierino. La mancanza del supporto FullHD, dato il prodotto, IMHO non è una penalizzazione eccessiva: in fondo, Apple TV è un “aggeggio” per fare streaming via Internet, e temo che nemmeno negli USA la banda sia sufficiente per fare streaming real time di contenuti 1080p.
• iTunes 10 visualizza a sx la thumb della copertina dell’album, e a dx l’elenco delle canzoni. Ottima idea: se non fosse che Windows Media Player e lo Zune player lo fanno da anni, oltre che “ottima” sarebbe stata anche “originale”
• Anche il “social network della musica” è una idea interessante; *2 anni addietro*, quando acquistai lo Zune, fu uno dei primi servizi che attivai: guardavo la mia pagina del profilo beandomi che i miei “top ascolti” fossero: Afterhours, Depeche Mode, Joy Division, Cure, … E nel sapere che i 4 gatti che lo bazzicavano lo avrebbero saputo. Al pari del punto precedente, sono contento che anche in questo caso le fotocopiatrici di Cupertino abbiano funzionato bene <g>

P.S.: Tra parentesi, l’idea del social network era talmente interessante che Microsoft l’ha ormai praticamente ridotta ai minimi termini, mentre Apple la cavalcherà e tutti crederanno che sia una sua idea. Un po’ come inventare XMLHTTP (e quindi AJAX) per poter implementare OWA e poi dimenticarselo lì per *anni*, e poi tutti a credere che ad innovare sia stata Google quando pubblicò Google Maps. Cose che succedono, se il marketing te lo fa Topo Gigio <g>

Am 15. September bin ich in Krefeld bei der netug-niederrhein zu Gast und werde dort einen Vortrag zu User Interface Design und User Experience halten.

Aus der offiziellen Ankündigung:

Viele Entwickler behaupten von sich freimütig, überhaupt kein Gespür für die Gestaltung von Oberflächen zu haben und können mit dem Begriff "User Experience" noch weniger anfangen. Wer es dabei belässt, macht sich die Sache jedoch ein wenig zu einfach, denn häufig ist es nur ein kleiner Schritt von einer schlechten zu einer durchaus akzeptablen GUI.

Dieser Vortrag stellt einige grundlegende Gestaltungsprinzipien vor, gibt praktisch einsetzbare Tipps und klärt u.a. was zugekniffene Augen und das Wissen um Fluchtreflexe mit Usability zu tun haben.

Es handelt sich dabei um eine leicht erweiterte Version des Vortrags, den ich auf der See# Party in Kreuzlingen (Schweiz) gehalten habe – sozusagen der “Director’s Cut”.

Die Veranstaltung beginnt um 19:00, weitere Informationen (Veranstaltungsort etc.) auf der Website der netug-niederrhein.

I can't say that I've ever known any kind of Web-based service to suck as much as Twitter, yet be as simple and popular. It really boggles the mind.

As just a regular user, it can be annoying enough with the constant outages and failures. As a developer, it's even worse. In my case, I put a simple hook in CoasterBuzz to publish links from our news page using our cstr.bz short URL's. At the time, you could do simple authorization, as well as OAuth. Since I wasn't dealing in nuclear secrets, and the .NET libraries for OAuth and/or Twitter were somewhere between weak and non-existent, I took the path of least resistance and did up some basic auth against a super simple RESTful URL. It took all of five minutes. And hey, all the docs said is that they'd support basic auth for a long time (or something to that effect).

Then yesterday, I noticed that the publishing is failing. I look at my error logs, and it's 401'ing. I do some looking around to find that they've turned off basic auth. To add insult to injury, I see this on their blog:

Fortunately, developers have known about our transition to OAuth since last December, so they’ve had time to update their apps."

Wow, really? Everyone knew? It's news to me. I pushed out my silly stuff in February, and there was no mention anywhere of any intention to discontinue basic auth, or dates or anything else. Lame.

So I'm chatting with a friend about this, and as we're chatting, lo and behold, e-mail from Twitter lands in our inboxes simultaneously. It contains this gem:

"Over the coming weeks, we will be making two important updates that will impact how you interact with Twitter applications. We are sending this notice to all Twitter users to make sure you are aware of these changes... Starting August 31, all applications will be required to use “OAuth” to access your Twitter account."

You know when this would have been great information? Weeks before September 1, when the e-mail arrived.

My issue is not about using OAuth (however much I'm annoyed that the once simple API is not simple anymore). In fact, the technical merits of using it aren't even an issue to me, as it took less than an hour to fix the problem, and most of that was just evaluating libraries. What annoys me to no end is how unprofessional these kinds of changes are. People are building businesses around Twitter. It's not OK to pull crap like this.

Between this and the annoyance of intermittent outages for the world at large, I can't understand how Twitter is the only game in town. I realize there's a critical mass issue, but the world is a fickle place, especially when it comes to the Internet. Perhaps it's because no one wants to get into a "business" that, to date, has no business.

Sometimes you’re so busy designing, coding, testing, and supporting a product that you don’t take the time to stop and appreciate what you have actually accomplished. A customer of ours asked us to create a video overview of our Silverlight functionality and in doing so we had to step back and say “wow”, this is pretty cool. It truly is easy to use EntitySpaces to create a Silverlight application as you will see.

This video shows the various pieces of an EntitySpaces application for Silverlight:

1) The EntitySpaces architecture itself.

2) The WCF Service to retrieve the data.

3) Some kind of row level, column level tracking on the Silverlight side of things (our proxies).

The good news is that EntitySpaces provides all three of these for you and more as you will soon see. The real beauty in this video is how the EntitySpaces server and client proxies are used to serialize data back and forth across the wire all the while tracking row level and column level dirty state. Also, the creation of the WCF service itself which utilizes the EntitySpaces architecture and allows you to take full advantage of the EntitySpaces DynamicQuery API under Silverlight is awesome. In fact, it’s hard to tell that you’re not on the server side because our client proxies look and feel just like the full EntitySpaces architecture.

Well, enough talk. Click on the image above and check out the video, it’s kind of large so give it a minute to download, but it’s worth it. Pay close attention to how few lines of code we actually wrote by hand to create our Silverlight demo, and how simple those lines of code actually are. There’s already a lot to learn when you start working with Silverlight, why not make it easy on yourself and use EntitySpaces? Our Trial version is fully functional and comes with everything you see in this video, including the demo in C# or VB.NET.

From Mobile Devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with Medium Trust requirements, a Silverlight/WCF application, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 300k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

http://www.adobe.com/products/flashplayer/support/index.html

1. Run MMC and load the services snap-in, kill the running squid process.
2. Empty Squid’s cache folder (e.g. C:\squid\vars\cache\).
3. Run Squid with the –z parameter to rebuild the cache folder structure (e.g. C:\squid\sbin\squid.exe –z).
4. From the services snap-in of MMC, restart the squid service.

Just find few useful tips/tool when I try to compare the schema and content of two SQL databases:

1. DBComparer (free)
   
2. List all tables in database: SELECT * FROM sys.Tables
3. List all tables and their row counts

SELECT 
    [TableName] = so.name, 
    [RowCount] = MAX(si.rows) 
FROM 
    sysobjects so, 
    sysindexes si 
WHERE 
    so.xtype = 'U' 
    AND 
    si.id = OBJECT_ID(so.name) 
GROUP BY 
    so.name 
ORDER BY 
    2 DESC

Entity Framework 4 brought a new way of dealing with references – directly through their foreign key value. While it takes off some abstraction, it’s more friendly to common situations in practice (e.g. selecting from drop down lists) and also it enables you to change a reference without having to load either the old referenced entities or the new one. Also note that this feature is optional; you won’t have your model polluted with foreign keys if you do not want.

This brings some new challenges in my scripts and old code dealing with EF metadata. Now I have to differentiate between “ordinary” simple properties and foreign key properties. Fortunately, it’s not that difficult.

You can get the matching foreign key property to a given navigation property by calling the GetDependentProperties() method which returns exactly entity properties which are dependent ones in the relationship. Note that we’re playing in the conceptual model area (which is what I want) and the foreign key column as implemented in the database could have different name. Also note that if there is a foreign key property, the method should return only value. If there isn’t (maybe you unchecked the “Include foreign key columns in the model” option in the Data Model Wizard), the collection will be empty.

And as usual some code for demonstration. It just outputs the list of all navigation properties in all entities and their corresponding foreign key property names:

var cx = new ModelContainer();
var mw = cx.MetadataWorkspace;
var entities = mw.GetItems<EntityType>(DataSpace.CSpace);

foreach (var en in entities)
{
    Console.WriteLine(en.FullName);
    foreach (var np in en.NavigationProperties)
    {
        Console.WriteLine("- navigation property found: " + np.Name);
        if (np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One || np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One)
        {
            Console.WriteLine("-- is to one");
            Console.WriteLine("--- its FK property is " + np.GetDependentProperties().ToList()[0].Name);
        }
    }
}

Whenever I develop an MVC application there is always some degree of data access required. As a best practice, I usually define a interface that my repository objects will adhere to. Creating an interface is generally a requirement for Dependency Injection (DI). DI is a very important pattern if you plan on doing any unit testing later on. For the purpose of this demo, I am going to keep things simple and only create a fake repository.  Here is the code:

public interface IRepository
{
    Person GetPerson( int id ); 
}

public class FakeRepository : IRepository
{        
    public Person GetPerson( int id )
    {
        return new Person { Id = id, FirstName = "Mike", LastName = "Ceranski" };
    }
}

Obviously, in a real-world application you would probably utilize the Entity Framework or LINQ to SQL in order to implement the IRepository interface. However, for the purposes of this demo the FakeRepository illustrates the point. Moving on, the next step is to create a base controller class which all of the other controllers in the application will derive from. The BaseController class has a IRepository property which gets set by the constructor. By having this constructor we can easily “inject” our repository objects.

public class BaseController : Controller
{        
    public IRepository Repository { get; private set; }

    public BaseController(IRepository repository)
    {
        Repository = repository;
    }
}

public class PersonController : BaseController
{
    public PersonController(IRepository repository) : base(repository) { }

    public ActionResult Details( int id = 1)
    {
        return View( Repository.GetPerson(id) );
    }
}

So at this point you may think your work is done, right? Well, if you were to run the application at this point and try to view the Details for the person with the ID 1 (“/Person/Details/1”) you would get an error stating that “No parameterless constructor is defined for this object”. That’s because the default controller factory used in MVC always uses the default constructor to create a controller. Since our PersonController does not have a parameterless constuctor defined, the application throws an error. Obviously, we will need to do a little more work in order to make MVC use our DI friendly constructor. Luckily this is easily accomplished by creating and registering our own custom controller factory. Here is the code:

public class CustomControllerFactory : DefaultControllerFactory
{
    public override IController CreateController(System.Web.Routing.RequestContext requestContext, string controllerName)
    {
        string fqn = string.Format("MvcApplication1.Controllers.{0}Controller", controllerName);
        Type controllerType = Type.GetType(fqn);
        if (controllerType != null)
        {
            var repository = new FakeRepository();
            return (IController)Activator.CreateInstance(controllerType, repository);
        }
        else
            return base.CreateController(requestContext, controllerName);
    }
}

The code above overrides the CreateController method. It uses the Activator.CreateInstance method to create the controller using our custom constructor and passes in a new instance of the FakeRepository class. So now the final step is to register the CustomControllerFactory in the Global.asax:

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();

    RegisterRoutes(RouteTable.Routes);

    ControllerBuilder.Current.SetControllerFactory(typeof(CustomControllerFactory));
}

Now, when I run my application and access the URL "/Person/Details/1" I get the following results:

The end result is a MVC application which allows you to easily inject repository objects for testing purposes!  The sample code is attached.

I recently discovered, the hard way, that Microsoft Vista still has a limit of a maximum 260 characters for the Path.   You can enter all the characters you want in [Control Panel | System | Advanced System Settings | Environment Variables | Path] but when you subsequently execute "Path" in a Windows Command Processor Console, you will see your stuff gets truncated at 260. 

 Worse, one day you will try to execute a command and it just won't happen,.and you may have one heck of a time figuring out why it failed.  Even worse, some sotware you run may try to execute an external dependency, under the reasonable assumption that it can be found in your path.  You're likely to have an even more difficult time diagnosing that!

How do you get a path longer than 260 characters?  Some forum trolls maintain that it's a ridiculous question and could only happen to a brain-dead Windows wimp.  Not me.  I'm senior software architect and engineer, and I try things out.  I'm always learning new technologies and experimenting with new tools.  You give me a shiny new machine with all the memory and processor you think is state of the art and I will soon have it filled up with developer goodies.  Now, if you, like me, start installing frameworks, language systems, editors, database systems, utilities, and other development tools, I guarantee you that you will soon blow past the inane 260 character limit!

So, here I am with a completely botched path.  What did I do?  I started replacing long entries with Environment Variables.  "C:\User\ProgLang\Ruby\Bin" became "%RUBY%."  You really need to be careful to put back-slashes ('\') where they need to go; a missing or extra back-slash can cause problems.

 It works, and if you replace enough stuff, you may get your path to display in a console.

Will your path always be useable by software?  Will it sometimes be corrupted and cause problems?  What happens when your Environment Variables get expanded?  Those questions I cannot yet answer, but you can be sure I'll be watching!

I’m back again with another edition of F# Discoveries this Week.  The most exciting announcement this week is the new F# August 2010 CTP which brings with it the ability to build your own VS2010 F# Express Edition with Visual Studio Shell and the prospect of building F# applications on Windows Phone 7.  Be sure to check out Daniel Mohl’s Windows Phone 7 template before getting started.

News and Upcoming Talks

F# (August 2010 CTP)

Announcing the F# 2.0 Standalone Tools Update

A standing invitation to F# users to "get in touch"

Don Syme lecturing at the F#unctional Londoners Meetup (9/9)

Tools and Libraries

WekaSharp: An F# wrapper for Weka (Yin Zhu)

F# and C# Win Phone List Template (Silverlight) (Daniel Mohl)

fsai Release FSharp AI library 1.10.0 (Lukáš Kouřil)

RockScroll: my new favourite Visual Studio Add-In (Kean Walmsley)

Video, Audio and Slides

Slides and samples from F# talk in Manchester (Oliver Sturm)

F# Intro Talk at NextGenUG in So’ton (Phillip Trelford)

Slides from Combinators, DSLs, HTML, and F# (Robert Pickering)

Busy .NET Developer’s Guide to F#: Basics (Ted Neward)

Technical Articles

iTunes via F# Interactive (Cameron Taggart)

F# for puzzles (Morse code decoder) (Brian McNamara)

Extracting elements from Win32 resource files (Luis Diego Fallas)

A variation on Matt Moloney's "Memento" pattern (Don Syme)

Bound Variables in F#: What Reflection Reveals (Neil Carrier)

Getting F# Running on a Continuous Integration Server (Ade Miller)

How F#'s async really works? (George Cullen)

Segment Tree in F# (Neil Carrier)

Bound Variables in F#: What Reflection Reveals (Neil Carrier)

Fuzzy Logic Experiments in F# (Neil Carrier)

Fuzzy Logic in F#, Example 1 (Neil Carrier)

Fuzzy Logic in F#, Now More Functional! (Neil Carrier)

F# “fun” with Windows Phone 7 (Fahad)

Getting started with Windows Phone in F# (Senthil Kumar)

Euler Problem 10 (Mark Pearl)

Euler Problem 16 (Mark Pearl)

Project Euler Problem 9 in F# (Stefano Ricciardi)

Project Euler Problem 8 in F# (Stefano Ricciardi)

Project Euler Problem 6 and 7 in F# (Stefano Ricciardi)

Enumerable.Skip vs Seq.skip (Mauricio Scheffer)

Getting Started and Evangelism Articles

Putting the fun in functional programming (Daniel Markham)

Back to school : Getting to know F# (Mehfuz Hossain)

Learning F# by writing C# (Alan Hemmings)

F# - sharper than C# (Josh Reuben)

Learning F# for C# developers (Bill Morrissey)

F# Community

Ars Technica - What do you think of F# ?

SO - How to merge sorted sequences in F#.

SO - Which to use, C# or F#? In this "real world" case

hubFS: F# Databse Application Samples & Articles

hubFS: MailboxProcessor.TryScan paradigm

I thought I would capture a few ideas around document libraries and share with the rest of the class. These are not “best practices” as I don’t want to sound too preachy so let’s call them “pretty good practices that you might want to consider if you have some time” (which is far too long for a blog title, hence the one I came up with is going to have to do).

SharePoint Fight Club

The first rule of SharePoint. I want you to repeat after me.

“SharePoint Document Libraries are not file shares.”

Good.

Now say it again.

Good.

Remember this, above all other things we’re going to talk about here, and you’ll be golden.

Document Libraries are not File Shares

I have to repeat this here because it is key. If your users are asking you to put a file share into SharePoint then you need to beat them upside the head when they talk about “replicating the folder structure” or “like for like” or “make it just like *that* (and points to file share)”.

If you really must make some kind of analogy and your audience knows something about databases (even Access), rather than saying document libraries are like file shares say “document libraries are like databases”. While SharePoint sits on top of a database it’s kind of irrelevant what the backing store is (side note, Dear Microsoft, please make a pluggable store for SharePoint in the next version) a list or document library is pretty much like a database. A document library may “look” like a file share just because it lists documents (which originated as files) and contains folders (assuming you left this feature on, more on that later) but it’s more like a database than a file share. Each document is just a blob associated with metadata (title, size, date, author, etc.).

A team once built a “document management system” in Oracle using… wait for it, blobs associated with tables with columns to hold the metadata for the blob. I laughed when they couldn’t store certain types of blobs and spent a ton of time trying to index the system and build a web UI on front of it (and yes, SharePoint was in the environment, that team chose to talk to me after they built it in isolation). True story.

Would you create a folder in a database? No. Great, let’s move on.

Working Online

Something that is going to be a big hurdle for your users (and yourself if you haven’t got into the mindset) is that  you do not need to create new documents on your hard drive. Ever. I see this behavior all of the time:

1. Start Word/Excel/PowerPoint
2. Create content
3. Save file to “My Documents” or some such silly place
4. Start browser
5. Navigate to SharePoint site and document library
6. Click on Upload
7. Navigate to find document on local drive

Really. Drives. Me. Nuts.

With the Office integration with SharePoint 2007 or SharePoint 2010, you’re able to fully integrate your editing experience with SharePoint. If you know your document is going to go into SharePoint then either a) save it to SharePoint when you’re done or b) launch a New document from the document library (which in turn will open the client app and save back to the SharePoint library by default).

It’s really simple to show users but will take some coaxing to get them to do this. Of course not everything belongs in SharePoint but it drives this SharePoint guy batshit crazy when I see documents in My Documents, a USB drive, a network share *and* SharePoint (of course every location has a different version).

Start using the tools as Microsoft intended you to and you’ll be in a better place.

Do_x0020_not_x0020_use_x0020_spaces_x0020_in_x0020_names

When you first create a new document library please don’t name it “Project Documents” or “Expense Reports – March 2010” or “Famous kittens I would like to juggle”. Instead name it “ProjectDocuments” *then* go back and change the name in the library settings. The reason why is when you create a new document library and call it “Project Documents” it takes on an internal name of “Project_x0020_Documents” and accessing that library in the browser will result in a url of “Project%20Documents”. That’s fugly not to mention a PITA to deal with.

Make everyone happy by crunching the name then going back to rename it to something more human friendly. Frankly I wish SharePoint did this automatically (like it does for publishing pages) but until that happens, we should make a mental note to do it ourselves and be good SharePoint citizens.

Hint: This is my golden rule for lists, columns, and views too!

Don’t Get So Attached

The worst sin (well, one of many) is some guy sending me an email with a document attached to it, usually about a minute after I get the alert the document was added to the library. Better yet, the document copied to a dozen people on my team. I can see the need for this if you have external users who don’t have access to your SharePoint site so that’s perfectly acceptable but you should really compose an email to them with the attachment and send the link to your internal team (I know, two emails are better than one? Your internal team doesn’t need the attachment).

It’s really simple to get a link to the document. Right click, copy shortcut, paste. Another tip when pasting the url into an email is to write a word to describe the document (or even “Document is here” is fine too) and highlight the word or phrase and hit Ctrl+K to create a shortcut. SharePoint links can get somewhat long and ugly so pasting that directly into an email can break up the readability. It’s an extra keystroke but worth the effort IMHO.

Lather, Rinse, Repeat

If you do live in the world where you are interested in versioning is important then go over the draft/publish model with your users. Draft versions have two attributes. First they’re minor versions (0.1, 12.3, 8,348,23.58,328). They’re incremented each time you check a draft version in (and have major/minor versioning turned on). Second, they’re only visible to people that have edit capability on the document library.

For example you have some requirement document that’s going to evolve and perhaps go through a few public versions (say one version for each phase; architecture, design, construction, etc.). The team agrees to use versioning and you twist their arm into a using draft/publish model. It’s really simple. Every time they have a minor edit, they check it in (leaving it in draft). The team juggles around reading it, making comments, pontificating, whatever until they’re in agreement of the contents. Then the custodian of the document checks the last version in and chooses to publish it. It becomes the next major version up and visible to readers of the site.

This works well because all of your minor edits are behind the scenes (and the number of them can be limited if you choose) and people get to see the polished product. Then it’s back to draft modes and “dot” versions, the cycle repeats itself, until the next major change. Treat documents as living entities that grow up (like an application, or a kid but without the mess) and maybe apply Semantic Versioning to them (publishing a major version when there’s something useful to communicate rather than bumping up the major version on every check in). This will cut down on the chatter between the team and readers don’t have to keep asking what the big change from 1.0 to 2.0 was (remember to add comments when you check in a major version).

Document1-draft.doc

How many times have you seen a document named this in a document library? True, you might not have versioning turned on but c’mon people. Really? That’s like using zip files for version control when you have a perfectly good SCM system in-house. The best part is that you look in the doclib and see Document1-draft.doc, Document1-final.doc, Document1-final.docx, etc.

Sit down with your users and explain the virtues of versioning. Maybe it’s not for them and maybe they don’t need full blown major/minor, draft, publish versioning. That’s fine. However if they’re going to be working on documents that evolve and need to be reviewed it’s probably time to show them a draft/publish model.

Bottom line, if you see the –draft, –final behavior then nip it in the bud before it becomes a problem. You don’t have to call your user out in the daily stand up and berate them in front of the team, but be supportive and helpful. Not everyone is a SharePoint Guru like you (and for good reason).

SharePoint Inception

There are some people that have done some nice things with folders (Laura aka “@wonderlaura” Rogers has a great article on Per Location Views). I feel these are exceptions to the rule. Systemically it probably stems from the file share stigma. People organize information using folders so it’s natural to them. The problem is that (remember?) document libraries are *not* file shares. Stop treating them like that.

Folders are like IFRAMEs. They were a great idea but as time went on, without people knowing any better or good ways to use them, they became ugly and nowadays IFRAMEs are pretty evil and frustrating and we don’t have a lot of them around. We’ve grown past them. Now let’s move on from folders.

A few things about folders that make them different from nuclear reactors:

• Document libraries have a path limitation (actually I think the limitation is on IE or maybe even HTTP) so nesting lots of folders inside of folders chews this up real quick. Trust me when you exceed the path. The error message you sometimes get is a blank screen.
• You generally have to know where something lives in order to find it. This can lead to dozens of clicks on folders depending on how great your folders are named.
• Folders are neither discoverable (other than the top level ones) nor searchable. Metadata is.

Folders don’t help organize information. Yes, I create a folder named “Expense Reports” but that doesn’t mean my smart users are going to put expense reports in them. Or a folder named “Architecture”. I guess I’m going to expect Visio drawings or stickmen or something in here but what happens when I start seeing server inventories in spreadsheets. Is it architecture or detailed design (or a document misfiled from some other project). Metadata and Content Types help you organize information.

Folders attach a fixed path to a document. If you drop something in a folder that’s how you retrieve it. If you decide one day to simply move it up or down the folder hierarchy, guess what? All those links are now broken. Using metadata to organize information means “I don’t care where this is but I know what it’s about”. Get into the habit sooner rather than later.

Where Am I?

Just a bit of a follow-up to using folders. One of the worst things you can do is drop a document library onto the home page of a site. Your site is for information. Try putting announcements, tasks, or pictures of kittens on your team/project home page. Not documents.

If you put a document library on the home page and have folders-from-hell enabled have you noticed the evil that is unleashed? No. Take a look again. Click on a folder. Now another one. Now another. Keep going until you’ve descended into the 9th level of Hell. Now take a good look at that url in your address bar. Go ahead. Click it. Now send it to someone with a note “I left your termination notice here” and paste in the link. When your unsuspecting suspect clicks on said link, nine times out of ten, he or she will be taken to… THE HOME PAGE of your site. Cool beans. Note that I said “maybe” so it’s not a guarantee but it’s also not very pretty. Like any Jessica Simpson movie pretty. And your users will grumble and gripe and blame SharePoint, not Jessica Simpson.

The other pro (or con depending on how full or empty your glass is) you get from dropping that beloved document library on your home page is the all important bread crumb trail. Pro or con, the breadcrumb trail that you see above a document library when you’re navigating through it is gone. It only exists when you send your users to the doclib itself so forget any navigation up the levels of Hell (or even knowing where you are if you care).

Metadata, metadata, metadata

Oh but Bil, I can’t find my documents without putting them in a folder called “My Documents”. Now after you noodle on that statement for a minute think about it. You unleash the fury of SharePoint on your team spouting commandments like “THOU SHALT PUT DOCUMENTS INTO THY DOCUMENT LIBRARY” and your team has no clue how to organize documents in a document library (let alone their own desktop) and you yell at them for not “categorizing” or “classifying” them properly.

Give yer head a shake.

You can’t bash people for playing the game incorrectly if you don’t give them the rules to the game.

Metadata is king in the SharePoint world. If you need to organize your documents dump them into a doclib and stick a column on said doclib called “Category” (or “LOLCATegory” if that turns your crank). Make it a choice field and let users add their own or make it a lookup into a list (or better yet use the metadata feature in 2010 but if you’re on 2007 we live in simpler times). Then create a view grouped by category. Create some searches on the category column. Create some views for categories the team feels important like “Important Architecture Documents” or “Things I would like to do to Bil if I could”. Pretty soon the team will be happy because they don’t have to spend 3 hours looking for a document that’s in front of their face.

Note that the space-in-names rule doesn’t apply to choices in a choice field. It doesn’t form a url and SharePoint doesn’t go tossing in its “_x0020_” macro on you. Be wild.

Breaking Boundaries

One final question about document libraries is how much is enough? How many document libraries do I need to store my documents. The answer my friend is “it depends” (oh you knew I was going to say that). Only you or your team or the collective wisdom of whomever is using the library knows what the right division is.

There are a few factors you can use to decide where to draw the line. Size might matter (although less so in SharePoint 2010). You might want to break up document libraries based on security. While you can apply security to (gasp) folders or items in SharePoint, it might make more sense to just seclude off a library for privacy. Remember when you created the first team site and got a “Shared Documents” library for free? There’s nothing but fear and common sense preventing you from creating a “Team Documents” and only allow members of the team to have read access (“Unshared Documents” just sounds a little badly in the grammar department).

I can tell you I don’t know what the right division of document libraries is but I can tell you what the wrong one is. One document library per document. Yeah, I’ve seen it. It’s evil.

Christmas Time

Okay, to wrap up let’s just remember two key things:

• Document libraries are not file shares
• Dumping files into folders is not organization

I’m sure there are more than two key things you can take away from this, but I had to end this post or else face eviction from my home.

Enjoy!

We frequently get ask for performance benchmarks on our forums. We typically try to avoid this as performance metrics from the company who is producing the product are dubious at best. We have been looking over ormbattle.net's performance metrics for a while now and we feel they are pretty fair comparison amongst the top .net ORM's. The results should be live pretty soon, however if you want a detailed break down of the EntitySpaces results head on over to our blog and check them out. As you can see EntitySpaces is very fast already and we will be continuing to optimize the areas where we are not at the top of the stack.

Permalink | Leave a comment  »

Summary

mvcConf was a free, virtual conference focused on ASP.NET MVC which ran on 7/22. We ran 25 sessions in three virtual rooms and had roughly 500 people logged on throughout the day. All sessions were run via LiveMeeting and were recorded. We were really happy with the community reception, e.g A public “well done” for the ASP.NET MVC Conference.

This post talks about how we ran it, what worked well, and where we can improve. The idea is to pass along the information to gather feedback and to help others who would like to run similar events.

There’s huge opportunity for virtual conferences. Unlike traditional conferences, virtual conferences. Some benefits:

• Can be run for very low cost
• Can be made available to anyone with an internet connection
• Require no travel or time away from family for attendees or speakers
• Can be very flexible, adding sessions and speakers at the last minute without any cost
• Can make different decisions on what content to provide by removing cost from the equation

Background

The conference was proposed by Eric Hexter and Javier Lozano, two ASP.NET MVP’s who have been running Community For MVC. C4MVC is a virtual user group with monthly presentations from the MVC developer community, presented over Live Meeting (the LiveMeeting account is made available via INETA). Eric proposed a full day virtual conference back in March. Eric said they were looking for help from the community, and I pitched is as one of the core conference team.

Pre-conference

In addition to e-mails, we used the following tools to keep things organized:

• Skype calls
• Project management via AgileZen
• Website built using WebMatrix
• Mass communications using CampaignMonitor

Day of conference

Meeting Rooms

We ran three concurrent tracks throughout the day, so we kept three LiveMeetings running and attendees moved between the meetings as they desired. Each room had a facilitator, who made sure things ran smoothly. I ran one of the rooms - it was pretty easy because the responsibilities were well defined and documented.

Track Facilitator Responsibilities:

1. Start a pre-recorded intro at the beginning of the session.
2. Start the server side recording in live meeting
3. Introduce the speaker for the session
4. Help the speaker, by letting them know if the video is rendering properly, audio is working properly , etc.
5. Monitoring the Question and Answer queue, and asking the questions verbally to the speaker.
6. Ending the recording at the end of the session.
7. Setting the live meeting slides to a pre-created slide while the next speaker gets prepared.

Backstage Room

In addition to the three Live Meetings which were used for the tracks, we had an additional "Backstage" meeting running all day. We used that for communications between the event organizers, and for AV checks with the presenters. AV checks were especially important since speakers were presenting from a lot of different locations and the schedule didn’t allow for the usual “Hmm… can you hear me yet? Not sure what’s going on here…” fumbling that begins 90% of Live Meetings.

mvcConf.com Website

All rooms had a landing page with instructions on how to join the meetings, and the Live Meeting links were handled via bit.ly links. Note that the Schedule page has “Join” links for each track.

Clicking a Join link takes you to a landing page for that room.

The “Join the live meeting” button links to http://bit.ly/mvcconf1 rather than an ugly Live Meeting link. We’ve all been on Live Meetings in which attendees had trouble finding the correct link; we found that this system made it easy to get where they wanted quickly. It also gave us the opportunity to get people involved in the Webchat.

Steve Smith’s company, Nimble Pros, donated a designer’s time to give us a professional website design. This kind of thing is huge for an all-volunteer effort – as Eric summed it up: “That type of donation was worth way more than any monetary equivalent. I would like to encourage that type of support.” Thanks, Steve!

Community Conversations: Twitter

We scheduled Twitter announcements for each session from the @mvcconf account using HootSuite. Example: Amir Barylko is presenting "Behavior Development Development" in Room 3 #mvcconf Join: http://mvcconf.com/Room?id=3

All the conference organizers were active on Twitter, encouraging as much community chatter as possible. Everyone used the #mvcConf hashtag, and recent tweets were displayed on the homepage at mvcconf.com using the WebMatrix Twitter widget.

Community Conversations: IRC

We ran four IRC sessions – one for each room, and a hallway chat. We linked to the IRC sessions from the site and talked them up via Twitter. There was a lot of activity on IRC – great discussions of the content, connections being made, etc. In several cases, attendees would help presenters out with demo problems by suggesting code fixes via IRC.

Attendees were free to use any IRC client they wanted, but we linked to webchat.freenode.net from all conference room pages and from the homepage of the site.

Session Recordings

Live Meeting offers two options for recording meetings – To My Computer or To Service. We used the Service based recording, as it’s both easier to manage (all recordings in one place vs. on different facilitator computers) and is supposed to be higher quality.

Note: The Live Meeting recording quality isn’t great. It’s 1024x768 and the audio is understandable, but it’s not at all ideal (more on that later).

Keynote

Scott Hanselman presented a very well received keynote presentation. He was the only presenter who also showed live video via webcam, which – especially for a keynote – added quite a bit to the presence and live feel. As an example of the flexibility offered by the virtual format, Scott (very graciously) presented the keynote while he was on vacation. As opposed to a standard conference, this didn’t require Scott to leave his home or spend more than a half hour away from his family.

Post-conference

Video

After the conference, we set up an online spreadsheet and had volunteers do some basic editing on of the recordings. We used Camtasia. Here’s the instructions our volunteers followed:

The goal here is to get a rough editing of the videos.

What I mean by this, is getting the beginning of the videos cleaned up so that some of the silly banter is cut out. Cut out any technical cliches that happened during the talks, in some cases audio from the presenter is lost and a moderator may work through the issue. I am looking for you to help get the part of the videos that provide no value because the presentation stopped. Also, I am looking to cut the Q & A sections at the end of the talks out. Again, these are general rules, if there is a question that adds to the value of the session, leave it in.

The process:

1. Download Techsmith Camtasia, you can use the 30 day trial of http://www.techsmith.com/download/camtasiatrial.asp
2. Watch the editing tutorial, http://www.techsmith.com/learn/camtasia/7/cut-spit-unwanted-video-audio
3. There are additional tutorials that will help, but the editing is a required viewing.
4. Update the spreadsheet to show which videos you are editing, and when they’re complete and uploaded.
5. Download the video
6. Edit the video:
   1. Open Camtasia studio
   2. Import media
   3. Add video to timeline
   4. Choose 1024 x 768 dimensions
   5. If necessary, use the zoom feature to remove black borders
   6. Use audio enhancements (volume leveling, voice optimization) if it improves audio quality
   7. Edit all audio and video portions of the video
   8. Produce as web 1024 x 768, mp4

By dividing up the labor, we were able to get all of the videos produced and online just a few days after the conference. We hosted the videos on Viddler and distributed via Bittorrent (using ClearBits.net, which hosts legal torrents).

Note: ClearBits is great because they only host legal torrents and offer a server-side seed. I recommended them to Jeff Atwood a long time ago and he’s been using ClearBits to host the StackOverflow Creative Commons data dump.

Tekpub also offered to mirror the videos on their channel here: http://mvcconf.tekpub.com/

Code Samples and Slides

All available code samples were hosted on Codeplex: http://mvcconf.codeplex.com/releases

Speaker Ratings

Speaker Ratings were handled via SpeakerRate.com here: http://speakerrate.com/events/503-mvcconf

All the sessions and speakers were set up before the conference so attendees could enter their ratings immediately after the session.

What Went Well

• Overall conference logistics
• Scale
• Website
• Session content
• Community involvement
• Microsoft involvement (good participation from product teams)
• Community response
• Post-event video turnaround speed

Note: To hear Phil Haack and Scott Hanselman discuss this from a speaker point of view, listen to Hanselminutes 224 (or read the PDF transcript).

Opportunity to Improve: Live Meeting

Overall, Live Meeting worked out pretty well. We ran a free conference with 25 sessions given by geographically distributed presenters without requiring special gear, servers, training, or extensive software setup. Live Meeting did have a few limitations, though.

Windows only client

We had 3 or 4 people complain about this. Since all sessions were recorded, anyone could get access after the fact, but it was unfortunate that a few people who wanted to view the presentation couldn’t (or wouldn’t) due to requiring the Windows software.

Live Meeting video quality is poor

Live Meeting’s audio and video quality are both good enough that the content is understandable, but they’re not good.

Live Meeting is conferencing software, not streaming video

Live Meeting is more immersive than the streaming video many conferences now offer, but it would be nice to offer both, especially for the keynote. Live Meeting takes a little more investment, has a limit of 1250 attendees per meeting, etc.

Options (in addition to staying with the status quo)

1. Offer Live Meeting + live streaming video. Offering streaming video would have allowed for “drive-by” attendance, unlimited overflow, probably some better video quality, etc. We tried to get that together for mvcConf but couldn’t find a free solution that would scale to 500-1000 attendees. If we did this, we could potentially use the video feed for higher quality video recordings.
2. Have a set number of presentation facilities (e.g. Channel 9 studios + potentially a few Microsoft Tech Centers), which could then handle Live Meeting, video streaming, and potentially some live attendees. This sounds good, but could require a good amount more organizational overhead.
3. Find another conferencing solution and if a cost is associated, charge attendees to cover it. Not ideal, but it’s an option.

I’ve taken a look at some Live Meeting alternatives. Some lists:

• Leading browser-based video conference tools
• Best Microsoft Live Meeting alternatives

So far, all the solutions that I’ve seen are prohibitively expensive once you want to broadcast to 500+ attendees, or allow several users to presenters. I’ve seen one interesting open source server solution, Big Blue Button, which bears more investigation.

Opportunity to Improve: Attendance Limits

We capped registration at 1000 for two reasons:

• Live Meeting caps attendance in one meeting to 1250. Note that with our 3 rooms (+ using the Backstage room for overflow) we could have scaled to 5000 if we’d pushed to the absolute limits.
• This was a first shot at it and we wanted it to go well.

Based on those factors, we “closed” registration at 1000. Note that this was really a soft registration cap, since actually entering the Live Meetings didn’t enforce a login, but we stopped publicizing the event once we hit 1000 registrants and didn’t pursue some easy high-profile publicity options (e.g. ASP.NET Community Spotlight listing) because we wanted to make sure everything went smoothly.

Opportunity to Improve: Local Events

Without changing our platform at all, we could have greatly broadened our reach by setting up local viewings of the conference using Microsoft facilities such as Microsoft Technology Centers, user group events, etc. These would have offered the following benefits:

1. Broad scale without any additional requirements from the conference organization point of view
2. Greater community feel by spanning both virtual online community and local community
3. Local publicity and promotion by locally respected leaders
4. Potential for follow-on workshops, etc.

(thanks to Clark Sell for this idea)

Opportunity to Improve: More Sessions

There are two ways to expand: more concurrent tracks, and two (or more) day events.

Offering more concurrent tracks is a small incremental cost – if we’re running three tracks, a fourth takes minimal additional effort in things like scheduling and logistics. It would require more effort in some areas, like video processing and setting up speaker ratings, so we’d need more event volunteers to scale, but not a whole lot more.

Making the event longer is harder, because the event was very exhausting to run. The only way this would be possible is if the second day’s sessions required a lot less overhead:

• Long workshops (half-day / full day)
• Open spaces meetings
• Dedicated tracks, like a full day Web Camps track

Opportunity to Improve: Logistics

The logistics went pretty well overall, but there are some things we’d do differently next time. From our retrospective meeting, in no particular order:

• Push IRC more
• Confirm speakers individually (we had a mix-up caused by confirming a group of speakers via a group e-mail thread, this would have been avoided by confirming individually)
• Get more session abstracts ahead of time
• Have more video editing volunteers set up ahead of time, and go to work on them as soon as each session ends
• Collect slides and sample code from speakers when they’re presenting (before or after presentation)
• Look into a Tuesday conference, vs. Thursday

Note: Please let us know of other opportunities to improve on the mvcConf UserVoice page.

None of this is specific to ASP.NET MVC

One important thing to point out is that none of this is specific to ASP.NET MVC. There’s no reason that we couldn’t see a lot more virtual conferences following this model, in any number of technology areas. Got one in mind?

Note: Eric and Javier got this conference off the ground and made it happen. I was happy to help out, but it would never have happened without them. I coordinated this post with them and incorporated their feedback, but please don’t assume that I’m trying to take credit for their awesome work. We just wanted to share our lessons learned with other people who want to host similar events.

And while I’m thanking people, I should of course thank the speakers (all of whom presented for free) and our generous sponsors.

Last night most of the DotNetnuke team and I traveled into Burnaby, to the BCIT campus where I gave a real quick (1 hour) presentation on the WebMatrix Beta, and Razor Syntax.

I was happy to see that we had over 60 people attend.  It was awesome to see the turn out on a hot summer evening. 

Download the Slide Deck

There were a number of questions which came up, I will try to remember them all here.

Working with Data – the db.Query() execution, can it be parametrized?

@{
    var db = Database.OpenFile("SmallBakery.sdf");
    var selectQueryString = "SELECT * FROM Products ORDER BY Name";
 }
@foreach (var row in db.Query(selectQueryString)){
  <tr>
    <td>@row.Id</td>
    <td>@row.Name</td>
    <td>@row.Description</td>
    <td>@row.Price</td>
   </tr>
}

Yes, you can.  Here is an example.

@{
    var db = Database.OpenFile("SmallBakery.sdf");
    var Name = Request["Name"];
    var Description = Request["Description"];
    var Price = Request["Price"];
    var insertQuery = "INSERT INTO Products (Name, Description, Price) VALUES (@0, @1, @2)";
    db.Execute(insertQuery, Name, Description, Price);
}
     

What and Who is WebMatrix and Razor targeted to?

Essentially the breadth developer.  Those folks that possibly come from a PHP background or even are new to the development world.  This will allow for them to onboard with a few minor tweaks to existing projects to get up and running as fast as possible.

Why is Web Matrix even needed when we have Visual Studio?

The initial thoughts are that this product is going to be free.  It will have a bare minimum feature set targeted to the scripter.  The UI is far simpler than what VS.NET Users are used to.  You could consider it as a a stepping stone into VS.NET.

There was some discussion around Razor Syntax and MVC.  Using it as a view engine.  Here are some resources to help with this answer.

http://gurustop.net/blog/2010/07/06/thoughts-on-razor-microsofts-new-asp-net-mvc-view-engine/

and

http://www.dotnetcurry.com/ShowArticle.aspx?ID=561

The topic of LightSwitch came up as well.  Here is the product page

http://www.microsoft.com/visualstudio/en-us/lightswitch

SIMPLEST WAY TO BUILD BUSINESS APPLICATIONS FOR THE DESKTOP, WEB AND CLOUD

Microsoft Visual Studio LightSwitch gives you a simpler and faster way to create professional-quality business applications for the desktop, the web, and the cloud. LightSwitch is a new addition to the Visual Studio family. Visit this page often to learn more about this exciting product.

Conclusion

All in all I felt the talk went well.  As usual I went a mile a minute and really tried to slow things down near the end.  Luckily there were enough questions to push us for the full hour.  If you attended feel free to send me feedback and ask questions.  I will do my best to get you the answers – just keep them on topic!

Resources for the discussion

http://www.asp.net/webmatrix

http://netbc.ca/DNCal/EventDetail.aspx?date=2010/08/24