Microsoft DevRadio: Spring Azure Update Review - IaaS, Web Sites, Licensing and more!

Abstract: Brian Hitney and Peter Laudati review and demo some of the latest updates and features made to Windows Azure such as the general availability of Windows Azure Infrastructure as a Service, Azure Web Sites, the Azure SDK 2.0 for .NET and the new licensing and pricing model. After watching this video, follow these next steps: Step #1 – Try Windows Azure: No cost. No obligation. 90-Day FREE trial. Step #2 – Download the Tools for Windows 8 App Development Step #3 – Start building your own Apps for Windows 8 Subscribe to our podcast via iTunes, Windows Phone Podcast Marketplace or RSS If you're interested in learning more about the products or solutions discussed in this episode, click on any of the below links for free, in-depth information: Blogs & Articles Brian Hitney’s blog Peter Laudati’s blog Windows Azure: General Availability of Infrastructure as a Service (IaaS) Windows Azure: Improvements to Virtual Networks, Virtual Machines, Cloud Services and a new Ruby SDK Announcing the release of Windows Azure SDK 2.0 for .NET Videos: Microsoft DevRadio: How to Get Started with Windows Azure Microsoft DevRadio: (Part 1) What is Windows Azure Web Sites? Microsoft DevRadio: (Part 2) Windows Azure Web Sites Explained Microsoft DevRadio: How to Integrate TFS Projects with Windows Azure Web Sites Virtual Labs: MSDN Virtual Labs: Windows Azure Download MP3 (Audio only) MP4 (iPod, Zune HD) High Quality MP4 (iPad, PC) Mid Quality MP4 (WP7, HTML5) High Quality WMV (PC, Xbox, MCE)

Bing Maps Mashup in Dark Skies

I’ve gotten a few requests about how to do a mashup in Dark Skies … so, thought I’d do a blog post on how it was put together.  First, what’s a mashup?   A mashup is an application that combines data from multiple sources into what is, hopefully, a more useful or interesting way to view the data.  They are often done as web applications because the data is often pulled from online sources.  But, mashups are ideal for Windows 8 and Windows Phone apps, too.  Dark Skies is simply a mashup that combines 3 main sources of data.  maps (from Bing), light pollution data (from sources like these: Save The Night, NOAA, and P. Cinzano), and favorite astronomy viewing locations and looks like so: What makes this interesting is the level of zooming, so you get really specific: Specific is good, but add in data sharing and you, hopefully, have an ideal mashup experience. Overlaying pins is easy as the map.  In fact, there’s a small sample on putting pins on a map here.   The harder part is storing the data, and for this, Windows Azure Mobile Services works really well.  I’ve talked about that in previous posts. The light pollution data is available from a variety of sources but in this case, a high res version with a color that can be made transparent (black) is ideal.  Credit: P. Cinzano, F. Falchi (University of Padova), C. D. Elvidge (NOAA National Geophysical Data Center, Boulder). Copyright Royal Astronomical Society. Reproduced from the Monthly Notices of the RAS by permission of Blackwell Science.   There are two fundamental problems in overlaying the two: first, the image should be sliced into small tiles to make it bandwidth sensitive (the uncompressed TIF file is 200MB).   The second is that the image doesn’t exactly line up.  It’s close, but there are subtle errors that get introduced despite both maps appearing to be Mercator projections.  There are a number of tools that can help you solve this problem, but in this case, I used MapCruncher.  It’s from Microsoft, and it hasn’t been updated since 2007, but … it works.  The idea is that MapCruncher can both transform/skew an image to fit the projection of the map, and carve it up into nice, little tiles.  Let’s take the following image: If I want to overlay this image at a specific point on the map. Let’s say that the two eyes should be where Lake Superior and Lake Huron are.  In MapCruncher, we’d bring in the image as an asset, and start defining matching points in the image, like so:     It’s not until we hit the lock button near the bottom left that the image is scaled/skewed/transformed to fit.  The closer an image is to being the same scale, the better/few points are required to get it look right.  Once you hit the Render button in the bottom left, it will go to town and slice and dice the image up, based on the zoom depth requested.  More on that in a second. In this case, it generated some 92 tiles.  When we preview the results, we can see the data is overlaid nicely: The tiles produced are laid out and named format known as quadkeys.   You can read a lot more about it here, but in short, each tile is scaled to fit the appropriate dimensions based on the current zoom level:   The pattern to this approach makes it very easy to know exactly what tile you need, and at what zoom level (detail).  Additionally, all of these files can be stored in a flat data structure (like a folder) which makes storage quite simple.  The best part is, Bing maps already knows how to build a quad key, so all you have to do is create a tile layer, and specify the quadkey as a parameter by putting it in curly braces, like so: MapTileLayer pollutionTileLayer = new MapTileLayer(); pollutionTileLayer.TileSource = "myurl.com/{quadley}.png";   But, this isn’t quite ideal.  One problem that I ran into is that if there are a large number of quad keys you don’t have (which is the case even in my app), there are a HUGE number of 404’s because the app has no way of knowing there isn’t a tile available for a specific quad key.  While the user doesn’t directly see this, it’s a lot of wasted traffic and just not clean.  The way to solve that is to roll your own GetTileUri handler. In my next post, I’ll detail the steps involved in setting that up!

Compressing as Individual Files in Folder

Let’s see how long it takes Jim Christopher to jump in with a better PowerShell solution.  :) I had a directory full of .avi files that contains RAW, uncompressed data at 60fps from a camera (for astroimaging).   Even capturing just a few minutes of data amasses  over 10GB of data: No wonder my drive filled up so quickly.  For archiving the data, I wanted to zip each file into its own file, not into a folder.  Because I had about 50GB of videos to do, I wanted a simple cmd to do it for each folder.  This is pretty easy to do with 7-Zip.  Bring up a command prompt in the folder you’d want each file to be individually zipped:     Assuming you have 7-Zip installed in its default location, use a command like: for %I in ("*.avi") do "c:\Program Files\7-Zip\7z.exe" a "%I.zip" "%I" -mx=5 -mmt=4 –tzip   You’ll see the progress in the command prompt: You can, of course, tweak that as necessary.   This compresses each file nicely, now consuming about 1.6GB.    This is a handy way to zip up large number of files into individual archives!

Skipping SSL Connections Locally

When developing locally, often times you don’t want to use SSL for a variety of reasons.  There’s no real point, since the request isn’t going over the wire.  Most of the time, connections are done via the loopback 127.0.0.1 address (although localhost can be used) which throws certificate errors.  This one problem is often easy to solve, but it relates to a bigger issue: dictating when (and when not) to use SSL on your site.  In the ol’ days, you wouldn’t want an entire site to be SSL for performance reasons.  Ideally, you want to gracefully redirect users to/from SSL based on the requirements of the page.  If a user navigates to a secure section like their account page, you’d like to use SSL.  If they navigate away to a page not needing SSL, you’d want to use http and not https.  There are a LOT of ways to do this, such as using MVC filters for MVC based applications.  One way I’ve solved this before was simply calling a method like so with each request: private void SetupSslIfNeeded() { //bail out on local connections – never need ssl if (Request.IsLocal) { return; } bool requiresSsl = false; string curPath = Request.Path; if (curPath.StartsWith("/account", StringComparison.OrdinalIgnoreCase) || curPath.StartsWith("/user", StringComparison.OrdinalIgnoreCase) || curPath.StartsWith("/admin", StringComparison.OrdinalIgnoreCase)) { requiresSsl = true; } //redirect to secure page if (requiresSsl && !Page.Request.IsSecureConnection) { string currentUrl = HttpContext.Current.Request.Url.ToString(); string newUrl = currentUrl.Replace("http://", "https://"); Response.Redirect(newUrl); } //redirect to non-secure page if (!requiresSsl && Page.Request.IsSecureConnection) { string currentUrl = HttpContext.Current.Request.Url.ToString(); string newUrl = currentUrl.Replace("https://", "http://"); Response.Redirect(newUrl); } } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } It’s a little more verbose than it needs to be, but it’s done to because there were a few port handling lines I left out for simplicity.  What this will do is avoid using SSL for local connections, and any page on the site except for those in the account, user, or admin folders.   The main downside of this approach is that it requires a redirect, which is a round trip to the server.  Ideally, you’d want your links to always be smart enough to know if they should go http:// or https://, but realistically, context switching between SSL and non-SSL pages is pretty rare so the client needing to endure the few extra milliseconds is an acceptable situation.  This is the way we currently handle SSL on http://www.rockpaperazure.com. 

Win8 Apps: Check for Network Connectivity

A lot of apps require internet connectivity to function – like my app, Dark Skies.   One thing I overlooked when first releasing Dark Skies was a graceful check for network connectivity.  If the app launches and there is no connectivity, it should fail gracefully and notify the user.  Ideally, we should also plug into the Network Status Changed event handler, so our app is notified when the internet goes up or down during the app’s session. There are a couple of ways to accomplish this.  If you’re checking for internet connectivity occasionally, you can do something like this: public static bool IsNetworkAvailable() { try { ConnectionProfile profile = NetworkInformation.GetInternetConnectionProfile(); if (profile == null) { return false; } else { var networkAdapterInfo = profile.NetworkAdapter; if (networkAdapterInfo == null) { return false; } else { return true; } } } catch (Exception e) { #if DEBUG throw; #endif return false; } } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } If you’re checking for connectivity frequently, you’ll likely want to cache that result in a variable, and simply change the cached status when the network status changes.  Wiring up the event is pretty simple: NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged; .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } And then the event handler can do whatever you’d like: private async void NetworkInformation_NetworkStatusChanged(object sender) { // ... } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } When the app loads, we’ll display a notification of some kind that internet connectivity is required:  Because the nature of tablets and internet connectivity, the state of the connection may change frequently.  Having a simple way to check for network connectivity and handling changes to the network status is a great way to ensure a smooth user experience! Oh – it’s also a good idea to check before doing anything that might throw a network-based exception.  For example, on app load, I made the mistake of always acquiring a push notification channel: await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync(); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } If the network is unavailable, this will throw an exception.  So, be sure to check for network connectivity and/or handle exceptions when setting up push notifications: private async void AcquirePushChannel() { try { if (IsNetworkAvailable()) { CurrentChannel = await PushNotificationChannelManager. CreatePushNotificationChannelForApplicationAsync(); } } catch (Exception ex) { #if DEBUG throw; #endif } }

Coding for Kids #3. Bugs!

In the first post, we introduced the problem.  We’re writing a program that solves the problem of finding 100 point words, where each letter in the word corresponds to its position in the alphabet (A=1, B=2, Z=26).  In the second post, we coded the basic solution that allows the user to enter a word, and we calculate the result. We have a bug, though, because we made the assumption that the letters passed in are lower case.  The word “automated” is a 100 point word, but “Automated” is displaying only 99 points, because the first “A” in the word isn’t getting recognized correctly.  Remember, in computer programming, we need to be precise. There are a couple of ways to solve this.  The first way will be to simply tack on extra if statements to deal with capital letters, like so: if (c == 'a') return 1; if (c == 'A') return 1; .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }But, we already decided this function isn’t all that efficient, and this doubles the number of if statements.  Fortunately, C#, and more specifically, the .NET Runtime that hosts the application, has a rich set of functionality in the base class libraries (that is, what’s “in the box”) that can do some typical work for us.   In this case, the string object contains a number of useful methods to convert the entire string to either upper or lower case characters. For example, we can modify the getWordValue function to something like this: 1: private int getWordValue(string theWord) 2: { 3: int wordValue = 0; 4:   5: foreach (char c in theWord.ToLower()) 6: { 7: wordValue += getCharacterValue(c); 8: } 9:   10: return wordValue; 11: } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Notice on line 5, we’re calling ToLower() on theWord, which converts the entire word to lower case characters.  If we rerun the application (F5) and try the word “automated” with a mix of characters, we’ll see we get the correct value: Even though we fixed the bug, our code is fragile.  What that means is that there are assumptions about the code that, if not corrected, will cause errors or unexpected behavior down the road.  For example, the getCharacterValue function still assumes the character is lower case, even though getWordValue anticipates that.  Sometimes, and especially in small projects, you just accept that the code is not ideal and move on.  Before we move on to reading files and finding 100 point words, let’s solve a couple of problems here in the code.   The first thing to understand is that computers store all data as 0’s and 1’s … called binary.  Each binary digit is called a bit, and 8 of those are called a byte.  The way computers translate those zeros and ones into a letter and words is through encoding.   Encoding is a standardized way to convert a binary number into a character.   Going through the ins and outs of encoding is worthy of a number of blog posts, but think of it like a map.  The computer sees a binary number like 01100001 – which happens to equal 97 decimal.   The computer has a character map that says the number 97 is equal to the letter ‘a’ (specifically the lower case ‘a’).   Without a character map, the computer has no way of knowing this is supposed to be an ‘a’.   As you might guess, the character map says the number 98 is equal to ‘b’, and so on, where ‘z’ is 122.   And while we’re at it, that character map also says ‘A’ (upper case) is 65, and ‘Z’ is 90.   These numbers have roots in a character encoding set known as ASCII, and it was convenient because all western characters could be represented in a single byte (more specifically, it could really be done with only 7 bits).  Today, it’s common for applications, and our runtime, to use Unicode – a more modern way to map the binary data to characters using extensible code points.  By extensible, it’s possible for Unicode to have code points that encompass virtually any number of languages. The point of the above, though, is that for English use, Unicode maintains compatibility with ASCII.  So, we can rely on those character numbers (65-90 for upper, and 97-122 for lower case) to tell us if we have an upper or lower case number.   Computers can process numbers _real_ fast, so instead of doing an evaluation of the character as we have been, let’s evaluate the number instead: 1: /// <summary> 2: /// Returns the value of a given character, where the 3: /// value is determined by its location in the alphabet. 4: /// (A or a = 1, B or b = 2, etc.). Case insensitive. 5: /// </summary> 6: /// <param name="c">The character to be evaluated.</param> 7: /// <returns>The numerical value of the character, 1-26.</returns> 8: private int getCharacterValue(char c) 9: { 10: //get the numerical/ASCII value of the letter 11: int charValue = (int)c; 12:   13: //if the character is an lower case letter a-z 14: if (charValue >= 97 && charValue <= 122) 15: { 16: return charValue - 96; 17: } 18:   19: //if the character is an UPPER case letter A-Z 20: if (charValue >= 65 && charValue <= 90) 21: { 22: return charValue - 64; 23: } 24:   25: //not an A-Z or a-z character, return 0 26: return 0; 27: } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } The first thing we’re doing on line 10 is creating a local variable, charValue, to hold the numerical value of the character, c, passed in.  (int)c is called a cast.   We know we have a character, but we want it represented as a number.  The cast allows us to do that.   We cast it to a variable (charValue) because it reads clearer and is more efficient than casting a char potentially many times over.  A word of warning:  you need to know what you’re doing when you cast.   It’s safe to cast a character as an int to get the numerical value, but when getting into more complicated scenarios, failed casts raise an exception which need to be handled (and exception handling outside the scope of this series).   In general, I wouldn’t recommend working with character values directly unless you really were sure of what is going on encoding-wise.  This is a good example of it being okay, because we have very specific rules and expectations, and the app is overall quite simple. Our if statements on line 14 and 20 look to see if the character’s numerical value falls in the given range.  The double ampersand (&&) is a logical AND operation so both conditions must be true for the if to evaluate to true.   If it’s a lower case letter, we simply return that value minus 96, which will give us a number of 1 to 26.   Same for the upper case, although we subtract 64 to get its value.  The code above is more concise, runs FAR faster (though, is _still_ not the best if can be), but it’s not quite as readable or obvious as to what it’s doing.  That’s where effective commenting comes in.  Notice, too, we solved the upper/lower case issue in a far better way – it’s not as fragile.   We do lose some flexibility, however – if the “game” changes and makes vowels worth double, for example, we’d have to go back to something else.  Also, notice we check for lower case characters first.  This is deliberate:  while it will handle either lower or upper case, if the characters passed in are more often than not lower case, we return the value and it’s one less if block that gets evaluated.   For the purposes of our program, it’s not significant except as an academic exercise in code optimization.  For now, we’ll call this “good enough” and move on to the next challenge:  finding words!

Coding for Kids #2. Code!

In my last post, I introduced the problem we’re trying to solve via an introductory computer program:  finding 100 point words where each letter of the alphabet corresponds to its place in the alphabet (A=1, B=2 … Z=26).  At this point, we’ve built the basic template for the app, but haven’t yet written any code.   It’s time to write some basic functions (or methods) that help solve this.  For coding veterans, remember – this initially is about solving the problem as a beginner and optimizing later.   When programming, it’s often easiest to work backwards – that is, the program flow is getting the user input, parsing it, then determining the value.   To write code to do this, it’s easiest to determine the value of a character first, working backwards.   So, let’s write a simple method that does this.   We’ll want a method that accepts a character, and returns an integer.  Within the code template established in the first post, add a method like this under the button click event handler: 1: private void btnCalculate_Click(object sender, EventArgs e) 2: { 3: 4: } 5:   6: /// <summary> 7: /// Returns the value of a given character, where the 8: /// value is determined by its location in the alphabet. 9: /// </summary> 10: /// <param name="c">The character to be evaluated.</param> 11: /// <returns>The numerical value of the character.</returns> 12: private int getCharacterValue(char c) 13: { 14: if (c == 'a') return 1; 15: if (c == 'b') return 2; 16: if (c == 'c') return 3; 17: // ... 18: if (c == 'z') return 26; 19:   20: return 0; 21: } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } The green text are comments.  Like the button method above it (that doesn’t do anything), our method is private (means it can only be used in this class), returns an integer (int), is called getCharacterValue, and accepts a character (char) we’ll just call c.  Normally, you’d want your variables, like c, to be clear names … such as firstName or dateOfBirth.  But for a simple character, it’s common to just use a single letter like this.  Remember, c is not “C” as in the letter of the alphabet – c is a variable that represents any possibly character.   All the code within the method must be encapsulated with curly braces { }.   Notice that we have a bunch of if statements.  An if statement evaluates a condition in parentheses.  If the condition is true, it executes the code that follows.    We could optionally execute multiple lines of code by putting it in curly braces, or include an else section.   The return command stops executing code, and returns the value if the function is true.  So, suppose that we do something like: int charValue = getCharacterValue('b'); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } The runtime (that is, what is executing our code) calls our getCharacterValue function passing in ‘b’.  We’re assigning the result of that call to an integer called charValue.   Logically, you know the result should be 2, and therefore, charValue should be 2.  If you were to follow the function as it executes, it would hit line 14 and see if the character is an ‘a’ … it’s not, so it keeps going.  It is a ‘b’, so it immediately stops executing and returns 2.   If the character passed in is ‘z’, you can see that it’s relatively inefficient.  We’re evaluating 26 if statements.   We’ll address that another time, but for now, it’ll do.   If it gets all the way to the end, we’ll return 0. My daughter asked me why we use 2 equal signs when comparing … such as c == ‘a’ … the short version is that one equal sign is assignment, whereas two is an evaluation.   Notice that in my one line sample code, we’re assigning charValue with a single equal sign.  That means we’re assigning the value of that function to our variable charValue.   Remember that computers need precise instructions, and so, in the if statements, we’re asking the runtime if these two things are the same – we’re asking it to evaluate.  We now have a method that determines the value of a single character … but what about an entire word?  Multiple characters in a computer program are called a string.   What we need to do is write another function that accepts a string, parses it for each character in the string, adding up the value of each character along the way.   To solve this, we need a variable to keep track of each character’s value.   We also need a way to look at each character in a string.  Fortunately, there’s an easy way to do that. 1: private int getWordValue(string theWord) 2: { 3: int wordValue = 0; 4:   5: foreach (char c in theWord) 6: { 7: wordValue += getCharacterValue(c); 8: } 9:   10: return wordValue; 11: } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } When our function is called, we’ll use a temporary variable called wordValue that we initially assign to zero.  Next we have a foreach statement.  A foreach is a fancy kind of loop.   There are different kinds of loops, with subtle advantages and disadvantages.  A foreach makes it easy to iterate over objects in a collection – in this case, characters in a string. What the foreach is saying is that for every character (called c) in theWord, execute the code in curly braces.  In that code block, we assign wordValue to itself plus the value of getCharacterValue of the current character in theWord.  (The += means ‘itself plus…’.)   If the word is “test”, the foreach code block is executed 4 times, the first time c is ‘t’, then ‘e’, then ‘s’, then ‘t’.  When that is done, wordValue should be the sum of each character’s value, so we’ll just return that. Now all we need to do is make it so when the button is clicked, we grab the value of the YourWord textbox, and display it in the WordValue textbox.  private void btnCalculate_Click(object sender, EventArgs e) { txtWordValue.Text = getWordValue(txtYourWord.Text).ToString(); } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } We can do this in one line of code in our button event handler.  First, one thing to know is that classes encapsulate functionality.  A TextBox is a class, as is our button.  We don’t have to worry about the inner workings of the textbox – such as how to draw the box, handle user input, etc.   The textbox contains a number of properties that can be accessed that make it easy for us to get or set the value of something within the class.  In the case of the textbox, it has a Text property that lets us get or set the value of the text in the textbox.  Properties are accessed by using a “.” – so, in the line above, we’re assigning the value of the Text property in the txtWordValue, and also reading the value of the Text property in the txtYourWord textbox. We call getWordValue, passing in the txtYourWord.Text value, which would be whatever the user types in the box.  Now, what’s that ToString()?   You’ll see ToString() a lot in C#.  Remember, with C# and many languages, you need to be very precise.  When getWordValue returns, what is it?  It’s an integer.  A whole number.  Computers deal with numbers differently and more simply than they do strings.   The Text property of the textbox gives you a string, and also expects a string if being assigned to.  We have a number.  So, in essence, calling ToString() turns, for example, the number 42 into the string “42”.  Let’s hit F5 and run the program.  Using the word “test”, we’ll see the following.  We’ll also try “automated” – an apropos 100 point word! Let’s not get too excited.  Let’s try it again, this time using the word “Automated” (notice the capital “A”): Our first bug.  We’ve barely written code and it’s already inefficient, buggy, etc.  The problem is that “A” is not the same as “a” … there are a number of ways to solve this, but we’ll look at those in part 3.    In the meantime, here’s the code for this version: Download VS12 Project

Windows 8 DevCamp: Raleigh

Microsoft RD Jim Duffy and I are hosting a series of events, kicking off with a Windows 8 DevCamp in Raleigh on Sept 25th!  I’m the brains, Jim is the talent, so don’t miss it.  Sign up here!  (Just kidding about Jim being the talent ) http://takenotewin8.eventbrite.com/ The DevCamp is designed to not only introduce you to developing on the platform, but also take active steps through the design, development, and submission phases to get your app into the marketplace.  Here’s the rundown: October 26th is right around the corner! Time is ticking away and the time to act is now! Microsoft Developer Evangelist Brian Hitney and Jim Duffy want to help you get your app in the store in time for the October 26 Windows 8 launch. Come join us on Tuesday, September 25, at 9:00 AM in the Microsoft RTP offices to learn how simple it can be to construct a world class Windows 8 application. Don't think you can be ready to join the Windows 8 launch? Come anyway. You might be surprised. Don't have any idea what kind of app to build? Come anyway. They're are plenty of places to look for inspiration. Either way you can learn what it takes to create or tune an app for Windows 8 and publish it in the Windows App Store. (Registration opens at 8:30 AM.) Windows 8 Overview and the Windows Store Haven't seen Windows 8 or know what it takes to get an app in the Windows Store? We'll cover that here. Drink your coffee because this first session will dive quickly into Windows 8, the platform, the changes, and the Windows Store, allowing you to monetize applications in a number of ways from in app purchases to subscriptions to trials. Cookbook I: Design Templates and Style In this session, we'll talk about the design principles for Windows Store applications – controls, color, typography, and general guidelines to follow to deliver the best user experiences. We'll also dive into the development choices and tooling support available. We'll begin with the built in templates and show how we can quickly scaffold a data-driven application called the Contoso Cookbook. Cookbook II: Data, Contracts, and Settings You've seen the Cookbook. But, how do we leverage data? How do we expose our data to allow users to search and share from the app? We'll explore these options in this session, from storing data, retrieving data via a web service using an in app purchase, to implementing search and sharing contracts, we'll look at the code that makes this possible. We'll also show how to store data locally, as well as roam preferences that can follow a user automatically as they log in to different devices. Cookbook III: Application Bar, Tiles and Notifications We've got the Cookbook well under way; now it's time to add some polish. We'll look at using the app bar for common tasks, and spend time talking about leveraging "live tiles" to create an up-to-date, engaging tile for your application. We'll also look at using Notifications, and how applications can run either background agents for various tasks, or be notified from a remote service using the Windows Notification Service. Hands On: [Your App Here] Now it's your time. Fire up your laptop with Windows 8 Release Preview (or RTM) and VS Express 2012 loaded on it and get ready to code!

Coding for Kids #1. The Beginning.

My daughter, a 5th grader, has shown an occasional interest in programming but having so many frameworks and platforms available today is both a blessing and a curse.  I began to learn programming by hacking Maxit, Hunt the Wumpus, Adventure, and others.   There were no graphics, no internet, no multiplayer. I saw her doing working on something when it occurred to me this would be a fun afternoon project to solve via code.  She was looking for “dollar words” – words that added up to 100 points (or cents, I suppose) where each letter is worth their index in the alphabet (A=1, B=2, etc.). I really liked this problem because it’s something that can be solved iteratively, and bits can be optimized later for further instruction.  If you’re like me, you immediately start trying to figure out the most efficient way to map a given letter to a point value … simple if/then?  Regex?  Character code map?   Lots of options!  Immediately, in this type of routine, you can see the tradeoffs between simplicity, reuse, and speed. I decided to write this series to be approachable by non-programmers and newcomers, because it can be a lot of fun to solve with your kids!   If you’re already a programmer, some of this may seem rather basic, but then, so is the problem(s) we are solving and it’s a great way to get started. Step 1.  Assuming you have never coded before, you need to download a code editor.   These are typically called IDEs for Integrated Development Environment because it can do much more than just be a text editor.   While we could technically write code in notepad, an IDE is often preferred because it can help you be more productive by compiling code, allowing you to debug, catching errors, and can autocomplete items.  Visual Studio is a fantastic IDE, and there are a number of free versions for problems just like this called Visual Studio Express.    If you don’t have it, download it now.  For this project, we’ll create a simple desktop application, so you’ll need the VS2012 Express Desktop version. Step 2.  Before we even start coding, it’s helpful to be clear on the problem.   We want a program that gives us 100 point words based on the scoring method mentioned above.  Ideally, it would be great if it could give us ALL 100 point words in the English language.  With a computer, we need to be explicit, so we’d want them sorted alphabetically.   While we’re at it, wouldn’t it be nice to let the user tell the program to find words of a certain value?  Why not 200 point words? These are great ideas for future versions, but let’s start simple.  The user types in a word, and the program displays the value of that word. Step 3. Launch Visual Studio.  If it’s the first time you’re launch it, you’ll need to select a profile, such as “C# Development Settings.”  We’ll use C# to solve this problem.  C# is a programming language.   A fun exercise in the future would be to convert this to another language – it’s a good way to learn a new programming language. Once loaded, select File > New Project.  On the New Project window, you’ll see templates which act as starting points for many different kind of applications.  Your screen may look different from mine, but essentially, you’ll want to select, under the Visual C# tree, the Windows > Windows Forms Application template.   Give it any name you’d like – in this case, I chose 100PointWords (though, you’ll see later why this name is limiting): Let’s familiarize ourselves with the environment.  Click the picture below for a larger version: This is the IDE.  On the left side of the screen is the Toolbox.  If you don’t see the Toolbox, you can click the View menu and select Toolbox from the drop down.    The Form1 we see is the design surface.   The design surface allows us to drag and drop, resize, and otherwise visually manipulate our application.   On the right side of the screen is the Solution Explorer window.  Our solution can contain any number of individual projects – in this case, we have only one, our 100PointWords application.   Form1 is currently loaded. If you double click on the Form1 design surface, you’ll go from design view into code view.   This will open the Form1.cs file and display the code associated with our application: 1: namespace _100PointWords 2: { 3: public partial class Form1 : Form 4: { 5: public Form1() 6: { 7: InitializeComponent(); 8: } 9:   10: private void Form1_Load(object sender, EventArgs e) 11: { 12:   13: } 14: } 15: } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Not a whole lot of code yet.  A namespace is a container that encapsulates any number of classes typically at the project level.   A class is used as a container for a given object, like a form (in this case).   This is partial class.  Without getting into too many details, what this means is that the designer file and the code file will get combined at compile time into a single class.  This makes it easier for us to work on code here, and keep the design separate where we can drag and drop items visually. Step 4.  Now, let’s start dragging some controls from the toolbox onto our form.  Switch back to the design surface tab.   Take a look at the screenshot below: Now just drag and drop some labels, textboxes, and a button from the toolbox onto the design surface (just drag and drop!).   They can be moved with the mouse, or fine tuned with the arrow keys.  A label is just that – some text.  We’ll have one label say “Your Word:” and the other label say, “Word Value:”.   We’ll have two textboxes – the top one is where the user enters a word, and the bottom is where we’ll display the word value. On the lower right side of the screen, you’ll notice we have the properties window for the current textbox, called “txtYourWord” … if you don’t see the properties window, right click the top textbox and select Properties, as shown in the screenshot above. By default, the textbox will have a name like “textbox1” and the button will be “button1” … it’s helpful to change these to reflect their purpose, so in the properties window, change the top textbox to “txtYourWord” and the bottom to “txtWordValue”, and the button to “btnCalculate”.  For the button, you’ll change two values in the properties window:  the text, which should say, “Calculate!”, and the name, which is “btnCalculate.”  There are a LOT of properties in that properties window – don’t let it confuse you.  We can ignore everything except the name and text values.  While you’re there, update the labels to something like the screenshot above (“Your Word” and “Your Value”). For controls like textboxes, buttons, etc., it’s common to use an identifier like “txt” or “btn” in the name so that, in code, it’s easier to recognize we’re dealing with a textbox and a button.  (This is known as Hungarian notation in computer programming speak.) With the mouse over the button, double click the calculate button: And you should see, in the code file: What we’ve just done is wire up an event handler.    This is a fancy way of saying, “When the user clicks the Technorati Tags: beginner,code,c#,development button, run this piece of code.”  Which, as of right now, does nothing.   An event handler simply responds to some type of event – like a button click.  Events are happening all the time – when a key is pressed, the mouse is moved, etc.    Notice that this function, btnCalculate_Click, has a few declarations.  The first is that it’s private.  That means this function (or method) can only be called from within this class.  Void is the return value – in this case, we’re not returning anything, so the return type is void.   The items in parentheses are items passed into the method.  For our purposes, we can ignore these for now. Now, if you’re really curious, you can open up the designer code file (Form1.Designer.cs) and see that all double clicking the button did was add this line of code for you: this.btnCalculate.Click += new System.EventHandler(this.btnCalculate_Click); We won’t go any further into event handling here, but event handling is key to modern app development. Congratulations!  We have the program laid out and ready for code.   We’ve leveraged the design surface to build the look of our application, and now what we need to do is dive into some code to make it all happen.   Stay tuned for part 2!

Windows Azure Trust Center

The Windows Azure team recently posted about the Windows Azure Trust Center.   One of the most frequent conversations that comes up when discussing moving applications to the cloud revolves around security and compliance, and it’s also one of the most challenging conversations to have.  What makes it particularly challenging is the fact that the responsibility of compliance is typically shared between the hardware, platform, and software. The site has a few sections that in particular drill down into security, privacy, and compliance related information.  Definitely good information to refer to when evaluating a move into the cloud!

My Apps

Dark Skies Astrophotography Journal Vol 1 Explore The Moon
Mars Explorer Moons of Jupiter Messier Object Explorer
Brew Finder Earthquake Explorer Venus Explorer  

My Worldmap

Month List