Paul Johnson's Technology Musings

New Silverlight 2 App Visualizes Social Bookmarking on MSDN and TechNet

2008-11-11T02:32:00Z

Updates have been posted to the MSDN and TechNet Social Bookmarking tickers. See John Martin's blog post for more information about the updates.

Learning C# Using Face-Off Queries

2008-11-05T00:18:00Z

Quite some time ago, I discovered a great way to learn and explore the C# language. It all started by doing the following internet search...

Class vs Struct

This query was based on a common interview question I've seen; "What is the difference between a class and a struct". If you make a quest to explore the results of this query, you can end up on an expedition of learning about the C# language. I still use this technique for reviewing the basics from time to time. The basic idea is to take common language types and/or concepts, and face them off in a term vs term query.

Based on how much valuable information can result from the Class vs Struct query, I've also compiled a few others that will take you further and deeper into a learning journey. The following queries can really help you learn about the language and will also lead you towards some VIP blogs and sites in the .Net community. Try them out and have fun exploring!

Instance Constructor vs Class Constructor

Array vs ArrayList

Dictionary vs Hashtable

Stack vs Heap

Interface vs Class

Interface vs Abstract Class

Value Type vs Reference Type

Thread vs Process

I hope these queries work as well for you as they have for me. By researching and understanding the results you find, you will have the knowledge to do quite well in C# development, and in any development interview.

Social Bookmarking Buzz

2008-09-11T23:36:00Z

Some great information, feedback, and reviews of the new Social Bookmarking application for MSDN, TechNet, and Expression have been coming through. See the following posts below about the new apps!

John Martin - http://blogs.technet.com/johmar/archive/2008/09/08/now-live-social-bookmarking-v-1-0-for-microsoft-msdn-technet-and-expression-sites.aspx

Chris Slemp - http://blogs.msdn.com/cslemp/archive/2008/09/09/launched-social-bookmarking-v1-on-msdn-and-technet-video.aspx

Somasegar - http://blogs.msdn.com/somasegar/archive/2008/09/11/social-bookmarking-platform-released.aspx

Dan Rigsby - http://www.danrigsby.com/blog/index.php/2008/09/10/msdn-social-bookmarks/

Dzone - http://www.dzone.com/links/msdn_social_bookmarks.html

Dotnetkicks - http://www.dotnetkicks.com/community/MSDN_Social_Bookmarks

Digg - http://digg.com/microsoft/MSDN_and_TechNet_Social_Bookmarking_Launch_Video

Yahoo Buzz - http://buzz.yahoo.com/article/1:787ce19b08403d28fd98d661ae62c0cd:f479fb24bc251bbe4cb88301743fc5d9

MSDN, TechNet, and Expression Social Bookmarking v1.0 Released!

2008-09-10T01:20:00Z

The new release of Social Bookmarking for MSDN, TechNet, and Expression is Live! Check out the new release with the links below and read about the new features.

TechNet Social Bookmarking

MSDN Social Bookmarking

Expression Social Bookmarking

Along with this release of social bookmarking, updates were also released to MSDN/TechNet Search and Forums. Some great new stuff to check out here and more on the way!

If you've been along since the preview release, here are some new features I think are worth checking out. To start with, there's now the ability to search for other users in the system. From this search, you can find that user's bookmarks, forum threads, and other community content, along with RSS Feeds. Speaking of RSS, we've added RSS Feeds for all users' bookmarks, which can be filtered by time range and tag. There are also new tools, including one to import browser bookmarks and other export formats such as del.icio.us.

Oh yeah, one more thing.. you can now tag something with "hyper-v"..

JavaScript Error : Operation Aborted

2008-09-09T23:19:00Z

Here's another tricky JavaScript error that could leave you bewildered and frustrated...

Internet Explorer cannot open the Internet site <site>.

Operation aborted

If you've encountered this error, you may be ready to strangle your computer already. When it happens, it crashes your page completely, with no way out. Well, the good news is, it has a specific cause and can be avoided. I found the answer on the IEBlog below, and was extremely grateful after too many hours spent trying to debug this. Hope this helps somebody else!

http://blogs.msdn.com/ie/archive/2008/04/23/what-happened-to-operation-aborted.aspx

MSDN and TechNet Social Bookmarking Release v1.0 (coming soon!)

2008-09-09T02:22:00Z

As many of you know, our Social Bookmarking application for MSDN, Expression, and TechNet has been out there for preview since late May. Meanwhile, we've been working hard on a full release, with some great new features and improvements. You can read all about the upcoming release here on John Martin's blog.

Be sure to check back here in the coming days for news about the new release!

Add MSDN/TechNet "Bookmarklet" to Any Web Page

2008-06-28T00:45:00Z

John Martin posted some snippets allowing you to add a "Bookmark on MSDN" link to any page. See below.

http://blogs.technet.com/johmar/archive/2008/06/25/add-msdn-technet-bookmarklet-to-any-web-page.aspx

JavaScript Error Resolved : Object doesn't support this property or method : document.all.tags

2008-06-28T00:10:00Z

Our team finally tracked down a troublesome JavaScript error in Social Bookmarking today. This was an odd bug, which will probably trip some other people up in the future.

The error below...

...was thrown on referencing the following JS object: document.all.tags

We found the problem to be an HTML div element on the page that had it's ID="tags". For some reason, this element ID caused the document.all.tags collection to be null. Good news is, the problem was easy to fix. We simply gave the problem Div a different ID, and the error is gone. Many thanks to our test team for tracking this one down.

For people using the Social Bookmarking app right now and experiencing this problem, know that a solution is on the way. It is in Test right now, and hopefully in Production soon. For future developers who try to ID an element "tags", hope this helps! :)

Web Widgets with .Net : Part Two

2008-06-26T00:19:00Z

Introduction

This is a continuation of an article about Web Widgets posted previously here.

This article builds upon concepts learned in the first article, so if you haven’t read it, I recommend you start there. It walked through the basic steps to create an HttpHandler to output JavaScript. Here, I will continue with that concept and build upon it by making a dynamic, data-driven, Web Widget.

The full working VS project with code examples for this article can be downloaded here:

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=webwidgetsdotnet&DownloadId=2331

The Base project to start with this in this article can be downloaded here:

http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=webwidgetsdotnet&DownloadId=2407

Events Widget Background

The purpose of the widget we are going to build is to display Developer and IT Pro Events from a data store. The events will be displayed as a list of hyperlinks that will take the user to more details about each event. This is similar to a web widget my group, STO (Server and Tools Online) built for MSDN and TechNet in 2007. This widget displayed events (Live Events, Webcasts, etc) for Developers and IT Pros, targeted towards their interests. The widget has since been replaced, during the latest upgrades to the sites, but a screenshot is below so you can get an idea. Note, the Data Access Layer used in my demo projects is returning example data.

http://i283.photobucket.com/albums/kk303/pajohnms/eventswidgetscreenshot3.jpg

Step 1 : Make it Data-Driven

If you look in the “Demo2 Start Here” project, you will see some new directories and files have been added since Demo1. First, notice the Data directory which contains two csharp files, DAL.cs and Event.cs. This is a very basic Data Access Layer which we’ll use to get example data to pass to JavaScript. Also notice that Core.js file has several functions added. These functions are used to create various controls, tags, event handlers, and to attach scripts.

1) Open up the “Demo2 Start Here” project and navigate to the files in the Data directory.

2) If you open /Data/Event.cs, you will notice the following attributes in the file:

[DataContract] attribute applied to the class

[DataMember] attribute applied to each property in the class

These attributes are what makes this class serializable. We will be serializing the Event Data to a format that JavaScript can use, called JSON. JSON stands for JavaScript Simple Object Notation, and is a simple way to define data structures in JavaScript. The DAL.cs file is our Data Access Layer, and simply has one method in it that will return a generic list of example Events.

3) Navigate to /Templates/Core.js and walk through the methods I’ve added here. We will use these methods in /Templates/EventsWidget.js to create controls, attach scripts, and stylesheets.

4) Navigate to /Templates/EventsWidget.js and notice the code that already exists here. I have created an EventsWidget object, and gave it two methods. We will be calling the render method at runtime to render the widget to the page.

5) Now to write some code. Open up Handlers/EventsWidget.cs. Add the following line to BuildOutput() method to access the DAL.

List<Event> eventData = DAL.GetData(5);

6) Next, open up Handlers/WidgetBase.cs. Add the following method, which we’ll use to serialize our Data to JSON format.

public string SerializeToJson(object obj)

{

var serializer = new DataContractJsonSerializer(obj.GetType());

using (var stream = new MemoryStream())

{

serializer.WriteObject(stream, obj);

return Encoding.Default.GetString(stream.ToArray());

}

This code uses a great feature of .Net 3.5, the DataContractJsonSerializer, which makes the job of serializing to JSON a snap.

6) Jump back over to EventsWidget.cs. Now we can serialize our data and pass it into the JavaScript template. Add the following lines below your GetData() call in BuildOutput().

string eventJsonData = base.SerializeToJson(eventData);

string placeholder = ConfigurationSettings.AppSettings["EventDataPlaceholder"];

output = output.Replace(placeholder, eventJsonData);

7) Notice the following config setting in web.config. This creates a string that we will use as a placeholder for the data in our JavaScript file.

8) Open up Templates/EventsWidget.js and add the following line to the constructor.

this.eventData = {eventData:placeholder};

This variable’s value will be replaced at runtime by the code we added in step 6. Then you can see that this variable gets passed into core.createHyperlinkList(), which loops through the data and creates a unordered list of hyperlinks.

9) Now that we’ve got data passed into our object, we can call the render method to display the widget. Add the following line to /Templates/EventsWidget.js at the very bottom of the file.

ev_w.render();

10) At this point, you can hit this in a browser. You should see a list of 5 hyperlinks from the event data, but they will be unstyled at this point. Next, I’m going to walk through adding a configuration setting to the querystring and adding a stylesheet.

Step 2 : Make it Configurable

Now I’m going to give adopters a way to configure the output of the widget on their site. The easiest thing to configure will be the amount of events to display. It seems quite feasible as an option adopters might want. I want them to be able to configure this in the script block they deploy, so the configuration variable will be sent in the querystring. Let’s start by modifying the middle-tier to accept this parameter.

1) Open /Handlers/EventsWidget.cs

2) Add a private member variable to hold the value for top number of events to display. Add the following line to the top of the class.

private int _topN;

3) Add the following method to the class to take the parameter out of the querystring and set the member variable we just added.

private void GetRequestParameters()

{

_topN = 5;

if (!string.IsNullOrEmpty(Request.QueryString["topN"]))

{

if (!int.TryParse(Request.QueryString["topN"], out _topN))

_topN = 5;

}

4) Reference the method we just added and change the hard-coded 5 value in GetData(5) to GetData(_topN). On the first line of BuildOutput(), add the following line.

GetRequestParameters();

5) Last, let’s add the parameter to the querystring in the script block. I’m going to change the value to 3, so we can tell it’s different from the previous 5 we were displaying.

src="eventswidget.jss?topN=3" >

</script>

6) Now, hit the widget again in a browser. You should now see 3 events listed (or whatever number you pass in).

Step 3 : Make It Pretty with CSS

Now, we’re going to attach a StyleSheet so that it looks a little better. You probably noticed I’ve been adding CSS class names on several elements in the JavaScript code. There is a stylesheet in the project that contains those classes, and now we’ll hook that up.

One important thing to note; when attaching objects such as other scripts, stylesheets, images, etc, you need to use the absolute path to those objects, since they are going to live on your host server. I have created a way to pass in a path from the middle-tier to the client-side tier, so that this doesn’t have to be configured separately for different deployments.

1) Add the widget path data in the middle tier. Open /Handlers/WidgetBase.cs and add the following to the ProcessRequest method. This will replace a placeholder value in core.js to give us the application path on our server.

string widgetPathPlaceholder = ConfigurationSettings.AppSettings["WidgetPathPlaceholder"];

if (output.IndexOf(widgetPathPlaceholder, 0) > -1)

{

output = output.Replace(widgetPathPlaceholder, Request.Url.GetLeftPart(UriPartial.Authority) + HttpRuntime.AppDomainAppVirtualPath);

}

2) Open /Templates/Core.js and add the following line to the constructor.

this.widgetPath = '{widgetPath:placeholder}';

Now, we have a widgetPath property we can use in any widget for attaching scripts, stylesheets, etc.

3) Open /Templates/EventsWidget.js and add the following line inside the render method.

core.attachStyleSheet(core.widgetPath + '/styles/main.css', 'eventsStyle');

This will call the attachStylesheet method in our Core object and pass in the widgetpath parameter we created. This method adds our stylesheet into the head element of the adopters HTML page.

4) View your widget in a browser. The classes from the stylesheet should be applied and it should have a more appealing look and feel.

Note; an adopter now has a default style for the widget, but with CSS they would also have the freedom to modify the style by creating more specific styles for these elements.

Now you have learned a way to create a web widget, using C# middle-tier, and JavaScript client-tier. This useful approach allows rich and easy content syndication that you can now put to use. It is a very powerful technique, and is also fun to build. I personally really enjoy working on a project that encompasses this many techniques, languages and technologies. It keeps development interesting and makes it fun. Enjoy.

Notes on Back Health for Office Workers

2008-06-20T23:40:00Z

If you work behind a desk, then you need to pay attention to your back. This is something I had to learn the hard way unfortunately. I am about 8 weeks out from rupturing a disc in my lower back, and in the process, have learned more about my back than I ever wanted to know. It's too late for me, as this is now a permanent injury. But if you haven't gotten to my point yet, then hopefully the following will help you avoid it.

A bit of history; it started with a bulging disc. This was an extremely painful experience that lasted for many months. The thing I learned most from this was the first point I want to share: If you have back pain for more than a couple days, go to the Doctor! The doctor will likely just prescribe muscle relaxers and painkillers. Note, these will do nothing to solve the underlying problem of a bulging disc. However, the doc can give you a referral to a Physical Therapist. At first, I scoffed, picturing a Physical Therapist as hooking me up to electrodes and watching me walk on a treadmill. I don't know where I got that perception, but it was wrong. The PT will assist you by helping you exercise, educate you about your back, and a bit of massage therapy.

There are some important things that the PT tought me about the causes of my injury. It was primarily related to long days sitting in a computer chair, with less-than-perfect posture. Over time, this can cause the discs in your back to push outward and eventually break through the fibrous tissue of your spine to push on your nerves. This is extremely painful, so mind what I say so you don't ever get there. Here's the key points to working behind a desk that I wished I had learned sooner.

1) Don't lean forward in your chair. This is horrible for your back and is a really common thing to do, especially when you really get into your work.

2) Don't sit for long periods of time without getting up. Make a point to get up, walk around, and stretch at least once an hour.

3) Try to keep your legs out in front of you, not curled back under your chair. This also helps enforce rule #1.

4) Get a chair with lower lumbar support. This helps push your back into the proper alignment, but not if you're leaning forward!

5) If possible, get a desk that can be adjusted to sitting and standing positions.

So, for me, I started to get much better after seeing a PT for some time. However, my arogance led me to be over-confident about my progress. I started riding my motorcycle, snowboarding, lifting heavy weights, and a few other activities before I should have. The problem is that I felt better, but really wasn't fully healed. These activities would've been ok, if I had just waited a bit longer. If you ever get to the point of healing from bulging discs, take my advice and take it slow. You will be able to do these things again, but you need to give it time. If you rush it, you might end up rupturing the disc, which is permanent, and will prevent you from doing some of these activities ever again. For instance, my orthopedic surgeon told me to forget about snowboarding, ever again. I can't tell you how disappointing that news was.

So, the good news is, I'm getting closer to recovery. I'm still struggling with pain and numbness, but I finally think I see the light at the end of the tunnel. The sad new is, I have dealt with this injury for over a year now, and can't imagine a day going by where I don't think about my back. I hope this advice helps somebody else, and would appreciate any additional advice or comments from others who may have been through this.

Web Widgets with .Net : Part One

2008-06-18T03:23:00Z

Web Widgets with .Net : Part One

This two part article is based on a presentation I gave at Tech Ed North America, Developers Week, 2008, about using .Net to create Web Widgets for the MSDN and TechNet sites. Part one will cover the creation of a basic widget, written in C# and JavaScript. Part two will update that widget to be more dynamic using C#, LINQ, JavaScript, JSON (JavaScript Simple Object Notation), and CSS.

Web Widgets : A Simple Definition

The best place to start is to give you a definition of Web Widgets. From Wikipedia.org, the following is a good description: “(a web widget) is a portable chunk of code that can be installed and executed within any separate HTML-based web page by an end user without requiring additional compilation.”

The basic idea is that a consumer site only needs to deploy a simple script block which requires no compilation. We achieve this by setting the script block’s source (src) parameter to a Uri on a separate widget host server. All server side processing is done on the host server, which sends back client-side script to render the widget on the consumer. There are probably hundreds of possible ways to build a Web Widget, but I’m going to walk through one specific example using .Net.

Typically, Web Widgets can be consumed on any domain outside the host domain. However, Browser Cookie data is available in the Request if in the widget is deployed within the same domain as it is hosted. Additionally, Request information such as Server Variables and QueryString are available in any domain.

Let’s Write Some Code : A Basic Widget using an HttpHandler

Now that we’ve covered some background about what we are building, let’s get to work. As I mentioned before, we are going to be using C# and JavaScript to build this. You could really use any .Net language for the Middle-Tier, but I found that the syntactical similarities between JavaScript and C# made switching gears between the two tiers a bit less jarring.

The code for this first example can be downloaded here: http://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=webwidgetsdotnet&DownloadId=2330

Step 1 : Create an HttpHandler Base Class for all widgets to use.

First, let’s create a base class that can be used for multiple widgets. It will handle the basic functionality of an HttpHandler. Note: I chose to use an HttpHandler here in order to avoid the overhead of the ASP.Net Lifecycle. There is no need in this pattern to use Viewstate, Page Events, or Postbacks, so I can avoid all the unnecessary overhead by using an HttpHandler.

1) Create a new Visual Studio C# Web Project and call it “Demo1”

2) Add a new directory called Handlers and add a WidgetBase.cs class file inside this folder. Mark that class as abstract since it will be our base class.

3) Implement the IHttpHandler interface

4) Using the VS2008 IntelliSense context menu, stub out the required members for an HttpHandler

This will add the following interface members…

IsReusable - property to let IIS know whether this handler can be re-used by other threads.

ProcessRequest(HttpContext context)- The main method of a handler. This is where we will do the work to write a response to the browser.

5) Set IsReusable to return false to ensure thread safety – We don’t want any other requests to come in and modify variables

6) Add null reference checks to ProcessRequest, to avoid null reference exceptions

if (context != null && context.Request != null && context.Response != null)

{

}

7) Add an abstract BuildOutput() method that returns a string. We want to force inheritors to use this method.

public abstract string BuildOutput();

8) Add a member variable to hold a reference to the HttpContext object that is passed into ProcessRequest

private HttpContext _context;

9) Response.Write the results of BuildOutput in ProcessRequest, using the Response object in the _context member variable just added in step 8.

_context = context;

_context.Response.Write(BuildOutput());

10) Add Request and Response shortcuts, using _context member variable. We will be using these shortcuts later, in the widgets that use this base class.

/// <summary>

/// Shortcut to Request object

/// </summary>

public HttpResponse Response

{

get { return _context.Response; }

}

/// <summary>

/// Shortcut to Request object

/// </summary>

public HttpRequest Request

{

get { return _context.Request; }

}

That is all the work we need to do in WidgetBase for now. Let’s move on to create a object of type WidgetBase.

Step 2 : Create an EventsWidget class and wire up the handler in IIS

1) Add a new class file called EventsWidget.cs to the Handlers directory

2) Implement the WidgetBase class and stub out the BuildOutput method using the handy VS2008 Intellisense dropdown

3) Create and return a string called “output” in the BuildOutput method and initialize it to the common “Hello World!” value, since this is the first time we’ll run this application.

public override string BuildOutput()

{

string output = "Hello World!";

return output;

}

4) Open an IIS Management Console and navigate down the application you are running this project in. (Create an application if you haven’t already)

5) In the application configuration features view, look for the “Handler Mappings” feature and double click it to see a list of existing handlers.

6) In the “Actions” area of this view, click the link to “Add Managed Handler”

7) Set up the new Managed Handler similar to the settings below.

Request Path: eventswidget.jss

Type: Demo1.Handlers.EventsWidget

Name: EventsWidget

8) The handler should be ready to run now, so let’s check it in a browser. Open up your favorite browser and navigate to the application you’ve been working in. Add the request path you created in step 7 above to the URI to hit the handler you’ve created. You should see a friendly “Hello World!” message on the screen.

Step 3 : Modify the HttpHandler to output JavaScript

1) Add a new directory called “templates” to hold script templates, and add a new file called core.js. This file will be used as a utility class to hold functions common to widgets.

2) Open /templates/core.js and add the following code to setup a namespace, constructor, and class definition for an object called Core. (Note: you should modify the namespace to match your own company or team)

/** Microsoft.Com.SyndicationDemo.Core.js: shared functionality for widgets **/

// Namespace definition : All Widget Classes should be created in this namespace //

if (!window.Microsoft)

window.Microsoft = {};

if (!Microsoft.Com)

Microsoft.Com = {};

if (!Microsoft.Com.SyndicationDemo)

Microsoft.Com.SyndicationDemo = {};

// Widget Core Constructor //

Microsoft.Com.SyndicationDemo.Core = function(message)

{

document.write(message);

}

// Widget Core Class Definition //

Microsoft.Com.SyndicationDemo.Core.prototype =

{

}

var core = Microsoft.Com.SyndicationDemo.Core("Hello from JS!");

The above JavaScript code is using a feature of the JavaScript language to create a class definition, called Prototype-based Programming. When we “new” up a version of this Core object, it will run the code in the constructor and write out a message via JavaScript.

3) Add a method to WidgetBase which will allow us to read the contents of the JavaScript file we just created. Modify WidgetBase.cs by adding the following method:

public string ReadFromFile(string fileName)

{

string fileContents = string.Empty;

if (HttpContext.Current.Cache[fileName] == null)

{

string filePath = HttpContext.Current.Server.MapPath(fileName);

if (File.Exists(filePath))

{

StreamReader reader;

using (reader = File.OpenText(filePath))

{

fileContents = reader.ReadToEnd();

}

HttpContext.Current.Cache.Insert(fileName, fileContents, new System.Web.Caching.CacheDependency(filePath));

}

else

{

fileContents = (string)HttpContext.Current.Cache[fileName];

}

return fileContents;

}

4) Modify EventsWidget.cs to read the JavaScript file using the method we just created. Change the content of the BuildOutput() method to the following:

string output = base.ReadFromFile(ConfigurationSettings.AppSettings["CoreJavascriptFileName"]);

return output;

5) Lastly, lets hook up this handler in a script block so that it actually runs in a script context. Add a new file called default.aspx to the root of the application. This file will serve as a test harness for our widgets. Add the following script block to the new page:

</script>

6) At this point, we can now hit the new default.aspx in the browser. It should display a friendly message from JavaScript. If you do not see any message, try hitting the handler directly to see if it is throwing an error.

In part two of this article, I will use this project as a starting point and make it dynamic. Part two will cover accessing data, passing data to JavaScript, and working with Styles via CSS.

Web Widgets with .Net Code Examples

2008-06-13T22:33:00Z

I've posted the code from the two demos I went through in my presentation at last week's Tech Ed for Developers. Both are posted at the Code Gallery link below.

http://code.msdn.microsoft.com/webwidgetsdotnet

(Go to the downloads page to access the projects.)

I am also working on an article that covers the material from the presentation. The article will use code from these projects and will also link to the Code Gallery resource page. In the meantime, let me know if you have any questions about the projects or how to run them.

Tech Ed Winding Down

2008-06-06T22:16:00Z

Tech Ed is winding down and things are mellow around here this afternoon. Quite a few people have solidified spots on the beanbags in hopes they might get to take one home. Word is, that if they are here at 6:00 this evening, the chairs will be theirs. Over in the Tech Ed Online area, a guitarist is playing and singing some nice mellow tunes for all of us.

My presentation on Web Widgets went well this afternoon. Thanks to all those who were there. I got a good turnout with about 60 or more people, which was more than I had imagined might show up. I guess the topic was an attractive one. I'll work on putting an online version up soon, as several people asked for it. Unfortunately, the lunch sessions weren't recorded, but I'll do what I can to get the content up asap. Look for my ppt, speaking points, and some code samples up here soon.

Going to the Party

2008-06-06T01:24:00Z

Well, we're over half-way through Tech Ed 2008, and tonight is the big attendee party at Universal Studios. I'm looking forward to tonight, as the party sounds like a blast. Our group was down at Universal City Walk last night, and found some good music, food, and dancing. So, I think tonight will be a good one too.

My days at Tech Ed have been quite rewarding so far. The MSDN Zone has gotten a ton of traffic, so I've gotten to meet a lot of new people. Most everybody seems quite impressed with the work we've done for the Social Platform on MSDN. I've gotten lots of comments about Social Bookmarking, with lots of "cool" and "great" and "nice job". It's a ton of fun showing off something I've worked so hard on.

Outside of the booth shifts, I haven't gotten to see very many sessions unfortunately. I did see STO's Tim Shakirian's presentation today on building the MSDN feed service with WCF. It was a good session that was full of new information to me. He spoke at a lunch session in a room similar to the one I'll be speaking in tomorrow, so that also gave me a chance to scout the environment.

Well, I need some dinner before this party, so I'm heading out. Below are a couple pictures of our MSDN Zone with people this time. The beanbags have been a real hit, as you can see.

First View of Tech Ed Venue

2008-06-03T06:50:00Z

I made it to Orlando safe and sound, though tired as I could possibly be. Walking into the main floor erased any tiredness I was feeling. I'm so excited to be here!

I arrived a bit late, so I wasn't able to get my speaker pass yet, and the MSDN booth was closed and under guard. However, I snuck a few pictures for y'all. Tomorrow this place will be full of people, enjoy.

MSDN Zone (pic 1)

MSDN Zone (pic 2)

MSDN Zone (pic 3)

Tech Ed : Which Way Do I Go?