I wanted to RDP into it, so I followed Planky's excellent instructions here (http://blogs.msdn.com/b/plankytronixx/archive/2013/11/12/running-a-remote-desktop-on-a-windows-azure-linux-vm.aspx)

BUT, when I connected via RDP, all I saw was a big gray screen.... no desktop! What's up with that???

I hunted around on Bing for a few minutes and found lots of people with the same issue and no solutions.

Then I found a pointer to the solution on the askubuntu.com website, which led me to . . . .

A step-by-step guide to setting up xrdp in Ubuntu 14.x http://c-nergy.be/blog/?p=5305

It worked for me.

Enjoy!

-bliz

So last night when the X1 gave me a BSOD, I thought BS! Right? I’ve been using Windows 8.1 since it first came out, with no BSODs at all.

I happened to have my phone handy, so I took a picture of the computer as it crashed and burned. The cause was a "DPC Watchdog Violation." But what caused that?

After I booted up, I dug in, looking for the root cause. Time to do some sleuthing. . .

If your computer has occasional issues, or if you just want to see what is going on behind the scenes, the Action Center is the place to go. ("Action Center." Heh. Sounds like something from a bad '90s teen flick, doesn't it?) It has all kinds of information about what's going on under the covers, so to speak.

To get there, open Control Panel (the desktop control panel) -> search for "Action Center" -> expand the "Maintenance" section -> click on "View reliability history"

The Reliability Monitor gave me this view:

Pretty sweet, eh?

I clicked on View Technical Details for the line that says "Windows stopped working," which brought up this view.

A memory dump. Awesome! You can use WinDbg to open a dump and see what the system thinks happened. (WinDbg is part of the Windows 8.1 SDK; for Windows 8, download from here): http://msdn.microsoft.com/en-US/library/windows/hardware/ff551063(v=vs.85).aspx). To open the memory dump, start WinDbg, File > Open crash dump…

Note: windbg was installed by default on my machine here: "C:\Program Files (x86)\Windows Kits\8.1\Debuggers" but the Windows start screen search can easily find it.

And for me, windbg said:

Probably caused by : igdkmd64.sys ( igdkmd64+657a3 )
Followup: MachineOwner
---------

When I did a Bing search for igdkmd64.sys, it gave me this: http://answers.microsoft.com/en-us/windows/forum/windows_7-hardware/bsod-with-igdkmd64sys-error/05a502bb-ea6f-45eb-880e-008b7bca748f which told me it could be the Intel Graphics Driver that caused the problem. (Sure the link is to Windows 7 answer, but it was good enough for me right now.)

At this point I had two places to look for a driver update. Windows Update or the Intel site. I started with Windows Update, and wouldn't you know it, when I ran it, there was a new optional update for the Intel graphics adapter. It hadn't been there yesterday when I ran Windows Update. (Curious that the update would appear just now. Very curious.)

Anyway, I've installed the driver update and my machine is humming along again. Let's hope that was the issue.

bliz

Doug Seven has a good blog post about the video series and the transformation, and included this diagram, below. We've had a tremendous increase in the delivery cadence, and in the value & quality of what's being delivered.

From http://dougseven.com/2014/05/15/scaling-agile-across-the-enterprise/

So, from your perspective, have we been successful? Are we doing things right?

How about at your company? Have you made the move to agile practices? How’s it going?

bliz

Building applications with SQL Native Client: http://msdn.microsoft.com/en-us/library/ms130904.aspx  From that page:

SQL Server Native Client is a stand-alone data access application programming interface (API), used for both OLE DB and ODBC, that was introduced in SQL Server 2005. SQL Server Native Client combines the SQL OLE DB provider and the SQL ODBC driver into one native dynamic-link library (DLL). It also provides new functionality above and beyond that supplied by the Windows Data Access Components (Windows DAC, formerly Microsoft Data Access Components, or MDAC). SQL Server Native Client can be used to create new applications or enhance existing applications that need to take advantage of features introduced in SQL Server 2005, such as multiple active result sets (MARS), user-defined data types (UDT), query notifications, snapshot isolation, and XML data type support.

When to use SQL Server Native Client: http://msdn.microsoft.com/en-us/library/ms130828.aspx

Using the SQL Server Native Client header and library files: http://msdn.microsoft.com/en-us/library/ms131291.aspx

ODBC How-to topics: http://msdn.microsoft.com/en-us/library/ms403288.aspx

Allocate handles and connect to SQL Server (ODBC) – includes sample code: http://msdn.microsoft.com/en-us/library/ms403303.aspx

OLE DB How-to topics: http://msdn.microsoft.com/en-us/library/ms403342.aspx

Enjoy!
-bliz

One is the “old school” way
As in, the SharePoint site that can be created for each TFS Team Project that’s created. Helpful info:
SharePoint can be used as the repository for artifacts associated with the development project, such as project plans, vision/scope documents, contact lists, etc. (i.e., things that aren’t typically stored in the version control system itself.) http://msdn.microsoft.com/en-us/library/hh667648.aspx SharePoint is a powerful solution that can be pimped out to the max. TFS reports can be exposed through the SharePoint Portal as shown below:

From the development side of things. . .
TFS can be used as a source code repository / version control system for your SharePoint development work, as it can for any other app dev. Basic, basic source code control. TFS doesn’t care what language or what type of solution is being created. Code is code. And TFS loves source code.

If you’re looking at build / deployment scenarios from TFS to SharePoint. . .
The TFS Build process can be used to deploy to SharePoint. These links provide some useful information about it:
http://www.alexandervanwynsberghe.be/deploying-sharepoint-2013-apps-with-tfs-2012/
http://officesharepointci.codeplex.com/

So, how are you doing things? Is your TFS environment hooked into SharePoint?

-bliz

Haven't tried Team Foundation Service? Get started for free today: http://tfs.visualstudio.com

-bliz

I thought about it for a second tonight, and it hit me: why not port the Silverlight game loop program I've been playing with over to the phone. It should be a snap! (http://blogs.msdn.com/b/jimblizzard/archive/2012/12/13/silverlight-game-loop-revisited-for-windows-8-and-visual-studio-2012-rtm.aspx)

Here were the steps I took:

I downloaded my Windows 8 Store app version of the source code from TFService and opened it in Visual Studio 2012. (If you haven't tried TFService yet, you've gotta give it a try. Take a look at http://tfs.visualstudio.com/.)

In another copy of Visual Studio I created a new Windows Phone App project.

Images

I copied the scene.jpg and snowflake.png files from the Windows 8 project into the phone project’s Assets folder.

MainPage.xaml and MainPage.xaml.cs

I copied the XAML from MainPage.xaml in the Windows 8 app to MainPage.xaml in the Windows Phone app, starting and ending with the <Canvas></Canvas> tags.

Since the screen sizes are a bit different between Windows 8 and Windows Phone, I adjusted the location of the image to put the lighted tree in the frame. And I moved the controls for Total Snowflakes, Volume, and Wind into the viewing area.

For the code behind file, I simply copied the contents from the Windows 8 app beginning with the List<Snowflake> line to the closing brace for the class.

I added using statements for System.Windows.Media and System.Windows.Media.Animation.

Then I changed both of the RangeBaseValueChangedEventArgs to RoutedPropertyChangedEventArgs<double>

Snowflake.xaml and Snowflake.xaml.cs

I added a new user control, calling it Snowflake.xaml, then copied the XAML starting and ending with the <Image></Image> tags.

For the code behind file, I simply copied the contents from the Windows 8 app beginning with double _posLeft = 0.0; line to the closing brace for the class. I didn’t have to make any other code changes in that file.

That’s all I had to do. And if you’re copying from the original Silverlight sample code, you probably won’t even have to do that much.

It was super easy and took less than five minutes. Good times. Bring on the Hackathon!

(Yes I had checked my Release Preview-based code into Team Foundation Service, but I couldn't remember which project I'd put it in. And I've rebuilt all my machines onto RTM bits, so I didn't have a local copy. But, there it was, sitting right where I'd left it on the server. I love the Team Foundation Service in the sky.)

OK. Where was I?

For some reason in my previous version when I created the project I wound up with the files that are included for layout aware pages. (Code that helps wire up a page to respond to Snapped, Filled, Portrait, and Landscape view changes.) Anyway, there was a change from RP to RTM that affected ApplicationViewStateChangedEventArgs and ApplicationView.GetForCurrentView(), both of which are used in LayoutAwarePage.cs.... One of those files that's part of the layout aware pages code that your project can leverage.

I took the easy route and created a new Blank C# Windows Store Application and copied my code from the RP version into the new project. And it worked without any changes. So now I yet again have a running snowstorm game in Windows 8.

Time to write a game of my own: perhaps using the accelerometer to send the snow moving left or right, or using the Shake event to allow the user to make it look like a snow globe that's been shaken. And of course I'll add ways to do this via touch, keyboard or mouse, for those who don't have those device sensors.

Stay tuned. . .

In future posts I'll discuss our source control strategy and (gasp!) how we handled bugs in our code.

A repository, please. . .

We were a distributed team and needed a centralized repository for source code, requirements, work items, and bugs. We were under tight time constraints and needed something that was easy to access, and couldn't afford the burden of trying to find and provision our own hardware. So, we looked to Team Foundation Service to help us out. Team Foundation Service gave us a powerful collaboration and agile planning environment in the cloud. It can do almost everything the on-premise Team Foundation Server can do. We simply registered on TFSPreview.com, selected a site name, and had our team project up and running within minutes.

Defining our team . . .

The team started with just three members, and two more of us were added over time. Adding team members to the TFS project was easy. Ian (our team leader and de-facto TFS admin) created accounts for us using our Microsoft IDs (you might know them as Live IDs). He use the online Administration tools to add team members and define security permissions for each of us. As a new team member came on board it only took a minute or so to make the entry and voila!

Once Ian added each us to the project, we were ready to go. We could access and update TFS through Visual Studio 2012 or the TFSPreview.com website. We now had our collaboration hub which allowed us to manage our PBIs and tasks; create, track, and close out bugs; and have visibility into how things were progressing throughout each sprint.

Defining our product . . .

When we created our Team Project we went with the Microsoft Visual Studio Scrum 2.0 process template. Since we didn't need to keep a rigorous audit trail and wanted to have the lightest amount of overhead possible, Scrum was the natural choice.

As we were trying to understand what we were going to build, we held Lync calls to discuss and refine details the vision of our Product Owner, Jit. At first we tried creating product backlog items in real-time using the TFS website, and I was acting as scribe and sharing my screen for everyone else on the call.

Depending on the amount of data we needed to capture we entered it directly into TFS via the website, or captured the data in Excel then published it directly from Excel to TFS. The options gave us flexibility and kept us focused on the task at hand.

Planning our sprints. . .

Once we had the PBIs defined, we organized them into sprints based on priority and size of the PBIs. We self-assigned PBI "owners" based on things we were interested in investigating, discovering, and coding. For example, Jerry wanted to work on the Hub page for the app, so he took that one; Ian wanted to work on the API layer that collected data from each of the data services we used; Jennifer wanted to work on Live Tiles and secondary tiles; I wanted to try out the Bing Maps control, so I took that one.

We weren't selfish about the items we'd chosen. We helped one another out as needed. For instance, Ian created some wicked-cool grouping code for restaurant "balloons" to keep the UI from becoming overly cluttered in areas where there was a large number of restaurants in close proximity to each other.

As part of the sprint definition we plugged our availability into TFS. We all have day jobs, so we wanted to make sure our sprint planning reflected the fact that we might only have a couple of hours every day or so to work on the project.

Team Foundation Service proved to be more than up to the job of allowing our distributed team to have visibility and insight into our current status and remained to be done.

Next post: keeping our source code in order.

(Want to learn more about the Team Foundation Service, such as how to get started, features, pricing, etc.? Here's your one-stop shop: http://tfs.visualstudio.com/)

In his posts he described game loop based on Silverlight 2. OK. Silverlight uses XAML, and the code was C#. XAML/C# are first-class citizens in the Windows 8 Metro style app world, so I figured, why not see what it takes to make this work on Windows 8?

The posts I used as reference:

• http://blogs.silverlight.net/blogs/msnow/archive/2008/09/22/silverlight-tip-of-the-day-44-making-it-snow-in-silverlight.aspx
• http://blogs.silverlight.net/blogs/msnow/archive/2008/09/29/silverlight-tip-of-the-day-50-main-game-loop-revisited.aspx

The first post contains the code for the majority of the application – the XAML and the C# code. In second post Mike switches the game loop to use CompositionTarget.Rendering instead of DispatcherTimer or the Storyboard timer. Are they still around in the Metro XAML world?

To find out, I open Visual Studio and took a look in the Object Browser. Guess what I found.

Yep. DispatcherTimer, Storyboard, and CompositionTarget are all alive and well in the Windows.UI.XAML namespaces.

So I figured, why not give it a try?

It turned out that most of the “work” was simple copy & paste. I had to change the using statements to point to the Windows.UI.Xaml namespaces for the controls. Had to change the signature for a couple of the event handlers. And a few other minor things.

Here are the steps I took to make the port.

MainPage.xaml

1. Create a new C# Metro style BlankApplication called Win8Snowflakes.
2. Delete BlankPage.xaml then added a new UserControl named MainPage.xaml. (Yes, we’re adding a UserControland naming it a page.)
3. Replace the contents of MainPage.xaml with the XAML for the UserControl Snowflakes.Page(from the blog post “making it snow”). Then . . .
   1. Replace All UserControl with Page
   2. Change x:Class="Snowflakes.Page" to x:Class=“Win8Snowflakes.MainPage”to match the name of the app & page.
   3. Remove the full screen Button. Just delete that entire tag. We won’t worry about going full screen.

MainPage.xaml.cs

1. Replace the contents of MainPage.xaml.cs with the C# code sample for public partial class Page : UserControl(from the blog post “making it snow”). Then. . .
   1. In the using statements you’ll see some red squigglies. To get rid of them, change Controls, Documents, Media, Media.Animation, Input, and Shapes to reference Windows.UI.Xaml instead of System.Windows
   2. Add the following using statement: using Windows.UI.Xaml.Controls.Primitives;
   3. Change namespace Snowflakes to namespace Win8Snowflakes
   4. Change Page : UserControl to MainPage : Page
   5. The method prototypes for the event handlers for Slider_ValueChanged and Wind_ValueChanged need to be changed. You need to replace RoutedPropertyChangedEventArgs<double> with RangeBaseValueChangedEventArgs, such as from this:
      1. Wind_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e) to this: private void Wind_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
   6. Remove the Button_Clickmethod. (We’re not going to deal with changing the window size for now.)
   7. In the MainPage()constructor, we need to change the way the event handler is defined and the signature for the event handler.
      1. To wire up the event handler, _snowflakeTimer.Completed +=_snowflakeTimer_Completed;
      2. And the new signature for the event handler: void _snowflakeTimer_Completed(object sender, object e)

Snowflake.xaml

1. Add a new UserControl to your project and name it Snowflake.xaml
2. Replace the contents of Snowflake.xaml with the XAML for the Snowflakes.Snowflake (from the blog post “making it snow”). Then . . .
   1. Change x:Class="Snowflakes.SnowFlake" to x:Class="Win8Snowflakes.SnowFlake"

Snowflake.xaml.cs

1. Replace the contents of Snowflake.xaml.cs with the C# code sample for public partial class Snowflake : UserControl (from the blog post “making it snow”). Then. . .
   1. Change the using statements just as we did in MainPage.xaml.cs to reference the Windows.UI.Xaml namespaces for Controls, Documents, Media, Media.Animation, Input, and Shapes
   2. Change namespace Snowflakes to namespace Win8Snowflakes

App.xaml.cs

1. In the OnLaunched() method, change rootFrame.Navigate(typeof(BlankPage)); to rootFrame.Navigate(typeof(MainPage));

Images

1. Download the zip file containing the two image files (one is for the background and the other for the snowflake) from Mike’s download link.
2. Unzip the files and copy them to your project’s folder.
   1. Right click on the project and Add Existing Item, and select the two files, to add them to the project itself.
      

Time to run the app. You should see this

The running app.Congratulations.

One more change

It’s very easy to change the game loop to use the CompositionTarget.Rendering event instead of a Storyboard.

1. In the MainPage() constructor for MainPage.xaml.cs
   1. Remove the following 3 lines:_snowflakeTimer.Duration = TimeSpan.FromMilliseconds(10); _snowflakeTimer.Completed +=_snowflakeTimer_Completed; _snowflakeTimer.Begin();
   2. And replace them with this one line: CompositionTarget.Rendering += CompositionTarget_Rendering;
   3. Change the signature for the event handler method itself
      1. from void _snowflakeTimer_Completed(object sender, object e)
      2. to void CompositionTarget_Rendering(object sender, object e)

And that’s it.

As you’ve probably heard over and over again, if you’re a Silverlight developer you have the skills to be a Windows 8 Metro style developer.

A great resource for developing Metro style apps on Windows 8 is http://dev.windows.com.

Happy Windows 8 developing!

--bliz (@snowstormlife)