So after my adventures yesterday with Win7 Beta 1 and no web access, I thought things were all cleared up. Tonight I realized my DVD Drive wasn’t being recognized. Going into Device Manager I saw that Windows had disabled the Drive because the driver being used was unsigned. Digging a bit deeper I find that one of the drivers being used is GEARAspiWDM.sys. This is a pretty common driver for DVD/CD RW drives, so I was intrigued why that was the issue.

Googling for GEARAspiWDM.sys I found the following article on ZDNet by Ed Bott, “An inside look at Apple's sneaky iTunes 8 upgrade”. The article talks about how Apple sneaks in a bunch of crap during their iTunes and QuickTime upgrades and doesn’t indicate what is being installed. I followed the articles suggestions about trying to roll back to a previous version, but, of course, there isn’t one on my system.

A quick trip to www.gearsoftware.com, Support, Drivers and I download Driver_Installer_x86_x64.exe Version 4.008.5, Date Feb 4, 2009. Running the installer is a snap, and I have my DVD Drive back.

Thanks Ed! Thanks Gear Software! Screw you Apple.

Namaste,

James

I always like to try the new software, and when I was at PDC last year I installed the Windows 7 PDC version natively on one of my laptops. No problems and when Beta 1 (Build 7000) came out, I decided to install it natively on my development machine. Never had a problem until yesterday – 3/21/2009.

I was working in Visual Studio 2008 and opened the Help file. I have it set to use Online help and was confused when it wasn’t displaying any pages. I started IE 8 beta to go to MSDN and that didn’t load. I then tried Firefox and got the same thing…no web pages. Ok, so maybe a reboot is in order – no affect. I checked Windows Update and the last update was on 3/19 with a Windows Defender definition file. I turned off Windows Firewall and disabled my ESET Nod32 Anti Virus and that didn’t help either. All the other machines on my network were fine.

I lost track of all the things I tried, but here is a list of things that were occurring

in “regular” mode, I could not access http, https or mail, but could ftp and ping

in “regular” mode the Network and Sharing Center showed full connectivity

in safe mode, I had full internet access – web, mail, ftp, ping

running a VPC of Win XP had full internet access

My great friend Rich Manley is an IT god and he couldn't figure out the issue. I then twittered another friend of mine, Stephen Rose, who is on the Windows 7 marketing team. He called me right back and asked a few questions, then said he would get me in touch with some of the devs. However, I have a project I'm working on and really had to get this fixed right away. Not wanting to do an entire re-paving of my machine, I decided to do an "upgrade" to Win 7 Beta 1. After 3 hours, and several reboots, I finished up with full internet connectivity again.

As soon as I was up and running again, Windows Update wanted to install 6 updates. I nervously let it do so, thinking at least I had a baseline to go back to if it crapped out again. Thankfully, that all worked out well.

The perils of beta software...

James

In preparing for my talk on SDS at last month’s Code Camp, I needed to figure out a way to join to SQL Data Services responses. I came up with this method using LINQ. I don’t know if its the best way to do it, but it works for me. I’d appreciate any feedback.

1. Master Page – Page_Load calls GetPodcasts()

2. GetPodcasts() gets two SDS responses, podCastDoc and guestDoc, does some LINQ, then returns a System.Linq.Enumerable

3. A ListView on the Master Page is bound to the podcast object.

Method GetPodcasts()

   1: public void GetPodcasts()

   2: {

   3:     AT_Podcasts at_Podcasts = new AT_Podcasts();

   4:     AT_Guests at_Guests = new AT_Guests();

   5:     XElement podCastDoc = at_Podcasts.SelectPodcasts();

   6:     XElement guestDoc = at_Guests.SelectGuests();

   7:  

   8:     if (podCastDoc != null && guestDoc != null)

   9:     {

  10:         var podcasts = from podcast in podCastDoc.Descendants("at-podcastdata")

  11:                        join guest in guestDoc.Descendants("at-guest")

  12:                        on (string)podcast.Element("GuestID").Value

  13:                        equals (string)guest.Element("GuestName").Value

  14:                        orderby (DateTime)podcast.Element("PublishDate")

  15:                        select new

  16:                       {

  17:                           PodCastId = podcast.Element("PodCastDataId").Value,

  18:                           PodCastTitle = podcast.Element("PodCastTitle").Value,

  19:                           PodCastPublishDate = DateTime.Parse(podcast.Element("PublishDate").Value).ToLongDateString(),

  20:                           PodCastAbstract = podcast.Element("Abstract").Value,

  21:                           RunTime = podcast.Element("RunTime").Value,

  22:                           GuestID = podcast.Element("GuestID").Value,

  23:                           GuestName = guest.Element("FullGuestName").Value,

  24:                           GuestCompany = guest.Element("GuestCompany").Value

  25:                       };

  26:         lvPodCasts.DataSource = podcasts;

  27:         lvPodCasts.DataBind();

  28:     }

  29: }

Method at_Podcasts.SelectPodcasts()

   1: public XElement SelectPodcasts()

   2:     {

   3:         XElement atPodCasts;

   4:         AT_SDSConfig config = AT_SDSConfig.Create();

   5:         Uri container = config.GetPodCastDataContainer();

   6:         string uri = container.ToString() + "?q=";

   7:         var request = AT_SDSUtils.CreateRequest(config, new Uri(uri), "GET", string.Empty);

   8:         try

   9:         {

  10:             var response = (HttpWebResponse)request.GetResponse();

  11:             using (var stream = response.GetResponseStream())

  12:             using (var reader = new System.IO.StreamReader(stream))

  13:             {

  14:                 XmlTextReader r = new XmlTextReader(reader);

  15:                 atPodCasts = XElement.Load(r);

  16:                 return atPodCasts;

  17:             }

  18:         }

  19:         catch (WebException ex)

  20:         {

  21:             AT_SDSUtils.OutputException(ex);

  22:             return null;

  23:         }

  24:     }

NOTE: at_Guests.SelectGuests() is similar, just going into the Guest Container

Results of SelectPodcasts()

   1: <s:EntitySet xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema">  

   2:   <at-podcastdata>

   3:     <s:Id>getting-restful</s:Id>

   4:     <s:Version>539244</s:Version>

   5:     <PodCastDataId xsi:type="x:string">getting-restful</PodCastDataId>

   6:     <PodCastTitle xsi:type="x:string">Getting RESTful</PodCastTitle>

   7:     <RunTime xsi:type="x:string">48:25</RunTime>

   8:     <Description xsi:type="x:string">Volkan talks about how to work with REST and process the XML with LINQ</Description>

   9:     <AdminNotes xsi:type="x:string">Great episode</AdminNotes>

  10:     <Abstract xsi:type="x:string">REST, XML and LINQ</Abstract>

  11:     <IsPublished xsi:type="x:boolean">true</IsPublished>

  12:     <GuestID xsi:type="x:string">volkan-uzun</GuestID>

  13:     <CreateDate xsi:type="x:string">1/23/2009 12:00:00 AM</CreateDate>

  14:     <PublishDate xsi:type="x:string">2/20/2009 12:00:00 AM</PublishDate>

  15:   </at-podcastdata>

  16:   <at-podcastdata>

  17:     <s:Id>sql-data-services</s:Id>

  18:     <s:Version>539554</s:Version>

  19:     <PodCastDataId xsi:type="x:string">sql-data-services</PodCastDataId>

  20:     <PodCastTitle xsi:type="x:string">SQL Data Services</PodCastTitle>

  21:     <RunTime xsi:type="x:string">12:35</RunTime>

  22:     <Description xsi:type="x:string">Jennifer goes into detail about how to use SQL Data Services to run a web site.</Description>

  23:     <AdminNotes xsi:type="x:string">This is the first podcast</AdminNotes>

  24:     <Abstract xsi:type="x:string">Using SQL Data Services to run a website</Abstract>

  25:     <IsPublished xsi:type="x:boolean">true</IsPublished>

  26:     <GuestID xsi:type="x:string">jennifer-louie</GuestID>

  27:     <CreateDate xsi:type="x:string">1/24/2009 12:00:00 AM</CreateDate>

  28:     <PublishDate xsi:type="x:string">1/24/2009 12:00:00 AM</PublishDate>

  29:   </at-podcastdata>

  30:   <at-podcastdata>

  31:     <s:Id>working-with-office-2007</s:Id>

  32:     <s:Version>539227</s:Version>

  33:     <PodCastDataId xsi:type="x:string">working-with-office-2007</PodCastDataId>

  34:     <PodCastTitle xsi:type="x:string">Working with Office 2007</PodCastTitle>

  35:     <RunTime xsi:type="x:string">30:45</RunTime>

  36:     <Description xsi:type="x:string">In this episode, Joe talks about a cool macro he wrote that makes all the busy work his boss has him do, a lot more fun.</Description>

  37:     <AdminNotes xsi:type="x:string">Kinda flakey, but ok to publish</AdminNotes>

  38:     <Abstract xsi:type="x:string">Office 2007 Macros</Abstract>

  39:     <IsPublished xsi:type="x:boolean">true</IsPublished>

  40:     <GuestID xsi:type="x:string">joe-blow</GuestID>

  41:     <CreateDate xsi:type="x:string">1/23/2009 12:00:00 AM</CreateDate>

  42:     <PublishDate xsi:type="x:string">2/11/2009 12:00:00 AM</PublishDate>

  43:   </at-podcastdata>

  44: </s:EntitySet>

Results of SelectGuests()

   1: <s:EntitySet xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema">

   2:   <at-guest>

   3:     <s:Id>jennifer-louie</s:Id>

   4:     <s:Version>50343029</s:Version>

   5:     <GuestName xsi:type="x:string">jennifer-louie</GuestName>

   6:     <FullGuestName xsi:type="x:string">Jennifer Louie</FullGuestName>

   7:     <GuestEmail xsi:type="x:string">jennifer@jennifer.com</GuestEmail>

   8:     <GuestCompany xsi:type="x:string">Louie Software</GuestCompany>

   9:     <GuestBio xsi:type="x:string">Jennifer is a .NET Rock Star. She's really cute and hot!</GuestBio>

  10:     <PublishEmail xsi:type="x:boolean">true</PublishEmail>

  11:   </at-guest>

  12:   <at-guest>

  13:     <s:Id>james-johnson</s:Id>

  14:     <s:Version>50404939</s:Version>

  15:     <GuestName xsi:type="x:string">james-johnson</GuestName>

  16:     <FullGuestName xsi:type="x:string">James Johnson</FullGuestName>

  17:     <GuestEmail xsi:type="x:string">james@james.com</GuestEmail>

  18:     <GuestCompany xsi:type="x:string">Duringlunch</GuestCompany>

  19:     <GuestBio xsi:type="x:string">James is a .NET Developer who has been writing software since punch cards. He often remembers the time when his Computer Science PhD project got scattered to the wind, when he stumbled across a brand new orange screen monitor and his breath was taken away.</GuestBio>

  20:     <PublishEmail xsi:type="x:boolean">true</PublishEmail>

  21:   </at-guest>

  22:   <at-guest>

  23:     <s:Id>volkan-uzun</s:Id>

  24:     <s:Version>49928700</s:Version>

  25:     <GuestName xsi:type="x:string">volkan-uzun</GuestName>

  26:     <FullGuestName xsi:type="x:string">Volkan Uzun</FullGuestName>

  27:     <GuestEmail xsi:type="x:string">volkan@volkan.com</GuestEmail>

  28:     <GuestCompany xsi:type="x:string">Uzun Enterprises</GuestCompany>

  29:     <GuestBio xsi:type="x:string">Inland Empire .NET User's Group Most Valuable Member - 2007/2008. LINQ Expert. Nice Guy.</GuestBio>

  30:     <PublishEmail xsi:type="x:boolean">true</PublishEmail>

  31:   </at-guest>

  32: </s:EntitySet>

Back to the LINQ which does the join

   1: var podcasts = from podcast in podCastDoc.Descendants("at-podcastdata")

   2:    join guest in guestDoc.Descendants("at-guest")

   3:    on (string)podcast.Element("GuestID").Value

   4:    equals (string)guest.Element("GuestName").Value

   5:    orderby (DateTime)podcast.Element("PublishDate")

   6:    select new

   7:   {

   8:       PodCastId = podcast.Element("PodCastDataId").Value,

   9:       PodCastTitle = podcast.Element("PodCastTitle").Value,

  10:       PodCastPublishDate = DateTime.Parse(podcast.Element("PublishDate").Value).ToLongDateString(),

  11:       PodCastAbstract = podcast.Element("Abstract").Value,

  12:       RunTime = podcast.Element("RunTime").Value,

  13:       GuestID = podcast.Element("GuestID").Value,

  14:       GuestName = guest.Element("FullGuestName").Value,

  15:       GuestCompany = guest.Element("GuestCompany").Value

  16:   };

  17: lvPodCasts.DataSource = podcasts;

  18: lvPodCasts.DataBind();

Again, like I said. I’d appreciate your comments.

J

Today I presented "SQL Data Services - A real life SDS Application. Even though my laptop siezed just before the presentation, it went pretty well. Here is the code and slide deck for your enjoyment.

AnonymousTypesCodeCamp-Johnson.zip (397.30 kb)

James

I like to help people. I also believe in the power and promise of technology. I’ve been thinking on this for quite some time and the people I have mentioned it to, have all given me great feedback. So, I give you “Geeks Without Borders”

http://geeks-without-borders.ning.com/

Come help me change the world.

James

Yesterday I did my first (and hopefully not last) geekSpeak with my friend Lynn Langit. I talked about SQL Data Services and had a great time. Today I received and email with my evaluation scores. Wow, I guess I did pretty good.

If you missed it and would like to hear it, or if you want to save it for your “I knew James when” archives, here’s the link, https://www.livemeeting.com/cc/mseventsbmo/view?id=1032400473&role=attend&pw=C76DF346

Next on the agenda… So Cal Code Camp. Come see the rest of the presentation as I continue to build out www.anonymoustypes.com.

James

Merry Christmas and Happy Holidays to all our friends. Can you solve the puzzle?

James

We work with an offshore country based at GMT + 5:30 to develop an application for us. Communicating with the contractors has been trying to say the least. Emails just don’t seem to get the point across about what needs to be done, or how I should set things up on my side. And, it seems they want me to be awake at 2:30 AM my time to answer the phone. After two weeks of trying to move the application from staging to production, with multiple points of failure, it was time for a phone call.

Ring, ring.

Me: “Hello”

Them: “Hi James”

blah, blah, blah, and niceties exchanged.

Me: “Ok, so let me get this straight. On the production machine, you want me to set the connection string to the XYZ report to the staging database? Doesn’t this defeat the purpose?”

Them: “Yes, set the connection string to the staging database.”

Me: “Are you sure? You’re positive right? This is the production server.”

Them: “Yes, please set the connection string to the staging database on report XYZ.”

Me: “On the production server?”

Them: “Yes on the production server, set the connection string to the staging database.”

(this isn’t going well)

Me: “Ok. Then anything else?”

Them: “Yes, when we move to the production server, make sure to change the connection string to the production database.”

Me: “Sigh….”

In the last post I talked about the structure of how SDS stores data. An Authority is geo-located and stores the containers. Multiple Containers can be stored in an Authority and each Container can hold multiple Entities.

I’m tired and need some REST, but after I wash with some SOAP

SQL Data Services support both REST (Representational State Transfer) and SOAP (Simple Object Access Protocol) interfaces which allows the use of practically any language and web development tools. For the rest of this series I will be focusing on interacting with SDS via REST.

Four kinds of URIs (Uniform Resource Identifier) are used when programming SDS with REST. Each of these URIs sets a scope for a set of operation to be performed. Each URI should look familiar by now:

Service – Used when creating and querying authorities

Authority – Used for creating and querying containers and to retrieve metadata regarding particular authorities

Container – Used for creating and querying entities, retrieving metadata about a particular container and for deleting a specific container

Entity – Used when retrieving, updating and deleting specific entities

Figuring out the pieces

Service URI

https://data.database.windows.net/v1/

In the URI above, data.database.windows.net refers to the Service while v1 references the version of the service.

A query can be appended to the end of the URI to query for Authorities which have been created, like this

https://data.database.windows.net/v1/q=’<some really cool query>’

Authority URI

To query against a particular Authority,  you prepend the URI with the name of the Authority you want to work with. For example:

https://duringlunch-01.data.database.windows.net/v1/

returns a single entity which contains metadata about the referenced Authority. The entity returned is XML like this:

   1: <s:Authority 

   2:     xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" 

   3:     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

   4:     xmlns:x="http://www.w3.org/2001/XMLSchema">

   5:       <s:Id>PizzaRecipes</s:Id>

   6:       <s:Version>2234</s:Version>

   7: </s:Authority>

As the same with Service URIs you can also append a query to an Authority URI to query against all the Containers in the Authority

https://duringlunch-01.data.database.windows.net/v1/q=’<a query to find containers>’

Container URI

The Container URI returns a single entity which contains metadata about the particular Container and returns the following XML:

   1: <s:Container 

   2:     xmlns:s="http://schemas.microsoft.com/sitka/2008/03/" 

   3:     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

   4:     xmlns:x="http://www.w3.org/2001/XMLSchema">

   5:       <s:Id>LatinaSpecial</s:Id>

   6:       <s:Version>1234</s:Version>

   7: </s:Container>

As with Authority URIs appending a query to the end of a Container URI will return all entities which meet the query criteria for the particular Container.

Entity URI

An Entity URI is a Container URI followed by an Entity ID and returns a specific entity

https://duringlunch-01.data.database.windows.net/v1/PizzaRecipes/LatinaSpecial/

   1: <LatinaSpecial

   2:  xmlns:s="http://schemas.microsoft.com/sitka/2008/03/"

   3:  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   4:  xmlns:x="http://www.w3.org/2001/XMLSchema">

   5:  <s:Id>LatinaSpecialPizza<s:Id>

   6:  <s:Version>13453</s:Version>

   7:  <s:DisplayName xsi:type="x:string">Latina Special Pizza</s:DisplayName>    

   8:  <Rating xsi:type="x:string">Great</Rating>

   9:  <NumberOfTimesMade xsi:type="x:decimal">250</NumberOfTimesMade>

  10:  <Description xsi:type="x:string">A mouth watering pizza with a Latina flair</Description>

  11:  <Pepperoni xsi:type="x:decimal">30</Pepperoni>

  12:  <Cheese xsi:type="x:decimal">24</Cheese>

  13:  <Crema xsi:type="x:decimal">5</Crema>

  14:  <QuesoFresco xsi:type="x:decimal">40</QuesoFresco>

  15: </LatinaSpecial> 

Security Model

Every Authority has a single user name and password (owner), and once authorized for a specific authority end point, full control over the Authority and the data stored within it is granted. Accounts are secured by SDS issued user credentials and only allows for communication by https.

Next…Query Support

One of the cool, and frustrating things, about dealing with cutting edge technology is how stuff changes so fast. Some of my links and bookmarks aren’t working until I start hacking the URL to find what it is I thought I had.

I’m going to make a minor change in plans and break my posts into two sub-categories; Hands-on learning and my experiences, and my interpretation of the online materials.

What are SQL Data Services (SDS)?

The SDS data model uses concepts of authorities, containers and entities. The data model has a flexible schema, which make it very easy to create your data structures.

The “ACE” Model.

A is for Authority:

C is for Container

E is for Entity

Homogeneous or Heterogeneous – everyone has a right to what they want.

As mentioned before containers can hold either homogeneous or heterogeneous data. Similar to a table in a database, homogeneous are entities which are all of the same kind. For instance a “Books” container stores all types of “book” entities. A heterogeneous container is more like an entire database with entities of all kinds. An example of a heterogeneous container would hold “book”, “office supply”, “furniture” entities.

Which is better? Hard to say, it depends on what your application needs. For the highly structured applications, use homogeneous containers. Heterogeneous containers allow for querying across all the entities stored in the parent container.

Flexible Entities

The key concept of SDS is the Flexible Entity. Flexible entities are XML fragments with one element per property value. Each property has a name and a value, with the value restricted to a simple scalar type of string, binary, boolean, decimal, or datetime. Each flexible entity has fixed metadata properties of “Id”, “Version”, and “Kind”, with “Version” acting as a timestamp. With each update, a new version is automatically assigned. “Kind” is user-defined, identifying the entity type. Entities can have additional user-defined flexible properties with any name and scalar type of the types listed above.

More soon,

James