A week later, he smiled at me and showed me his guitar.  The stolen guitar had been returned, along with an amazing story.

After the guitar was stolen, it was purchased on the street by a man who had hoped to present it to his nephew as a gift.  The new owner was curious about his purchase and went online to learn more about it.  He performed a search on the Internet, entering all of the words that were engraved on the guitar.  Rather than retrieving manufacturing information, the search engine brought back reports of the stolen instrument, along with the name of the owner.  The person picked up the phone and contacted my guitar teacher.  He said, “I may be out $300, but I should return this to its rightful owner.”

I’m happy to hear that there are still honest people left in the world.  My guitar instructor said the man wouldn’t take money for the guitar.  He ended up giving him a Starbucks gift card.  I hope that man receives all the good karma he deserves.

Back in 2010, I complained that the “new” filter that Twitter had implemented would limit the conversations that we’d see. (The “@ reply” filter prevents you from viewing conversations between two people unless you follow both of those accounts.)  My original post suggested that we would be exposed to fewer conversations and thus prevented from discovering new and interesting people. While I still believe that’s true, I think it matters more when you’re first building your Twitter connections. Just in case you aren’t aware of the workaround for the filter, you can take a quick peek at that older post.

This morning, however, I was thinking how we might be able to put that filter to work for us in another way. Although this is pretty obvious, I haven’t seen it discussed, so I’ll outline the general idea here.

Although the @ reply filter could be used for any conversation, the “chat” is a perfect use case.

• Create a new Twitter account that will be used specifically for a “chat.” For example, “@CoffeeTalk.”
• Now, tell everyone who wants to participate in Coffee Talk to “friend” the CoffeeTalk account.
• If everyone in the group replies to “@CoffeeTalk” in every tweet, those replies would only be published to the streams of people who follow @CoffeeTalk.

This is similar to a chat that uses a hashtag, but you don’t need any special tools to filter the tweets.  You’d be doing your other followers a favor by not cluttering their streams and the famous @ filter would finally be put to good use.

What do you think? Have you seen this suggestion before?  Could this work for you?

I’m calling this experiemental because I have some additional ideas for the extension. I’d like to enable Google Contacts and Facebook searches in addition to the initial Twitter search.

If you are a Chrome user, please give it a try and feel free to provide feedback. I’m open to any suggestions you might have to enhance the experience. You’ll need to become a Contaxio member and sync your Twitter account before using the extension.

From within Chrome:

Click this Link to Install the Extension

My main purpose for this post is to create a quick list of the Republican frontrunners and figure out if there’s any reason I should do anything but use the write-in box.

I’ve seen a few tweets that say, “Anything would be better than what we have now.”  But, just for a minute, let’s not even consider the other party.  If I look at this list, I don’t really see a choice.

We have so many amazing people in America, and this is the best we could come up with?  Is there still a chance to have a real candidate join the race — please?

These types of mistakes can be frustrating because they’re not programming errors. You left something out of the deployment package, but you don’t want to go through the long deployment process again just for this minor change.

In the past, I’ve used Remote Desktop to perform updates on each web role instance, but that can be very tedious. You can use Web Deploy if you’re only using one instance, but that isn’t practical. I saw one other approach that uses NuGet, which looks interesting, but isn’t quite what I want.

Update: Of course, I wrote this post and then saw the Windows Azure Accelerator. I’ll give it a try and write a follow up post. It looks like a similar solution, but it polls for updates. I’m not a big “Web Deploy” user, so I can’t comment on the degree of deployment control. I think it’s worth reading the rest of this post so you can decide.

I needed something simple to end my frustration, so I wrote PatchAzure. The code allows me to upload a patch to Azure Storage and apply the updates to all Web Roles. Each patch is a simple zip file that unzips into the webroot of each Azure instance.

The patching process is triggered whenever the Azure configuration file is updated and when the instance is started. Each patch is applied only once, unless the instance is rebuilt.

The patching process is triggered whenever the Azure configuration file is updated and when the instance is started.

There are just a few code changes you’ll need to make to your existing Azure Web Role Project.

1. Include the PatchAzure.cs file in your project.
2. Then update WebRole.cs with the changes in Listing 1. Update the credentials with your storage credentials.
3. Add the “patch” setting to your Azure configuration file (Listing 2).
4. Deploy the project, and you’re ready for your first patch.

Listing 1

WebRole.cs

     ...

	  public override bool OnStart()
        {

            RoleEnvironment.Changed += RoleEnvironmentChanged;
            PatchesApply();

            return base.OnStart();
        }

        private void RoleEnvironmentChanged(object sender, RoleEnvironmentChangedEventArgs e)
        {
            PatchesApply();
        }

        private void PatchesApply()
        {
            try
            {
                //Get the path to the website
                //Using ServerManager since other methods aren't available in WebRole.cs.
                //Reference: Microsoft.Web.Administration.dll in %WinDir%\System32\InetSrv (Copy Local=True/Specific Version=True)
                //Note:  This will not work for testing with the emulator.  Hardcode rootdir if needed.
                ServerManager server = new ServerManager();
                string rootdir = Environment.ExpandEnvironmentVariables(server.Sites[0].Applications[0].VirtualDirectories[0].PhysicalPath);
                //*********************************************
                //Check for new patches.
                //*********************************************
                //Blob Storage Account Name
                string accountName = "{account name}";
                //Blob Storage Key
                string key = "{storage key}";
                //Blob Container where patches are stored.
                string patchContainer = "patches";
                //Comma-delimited list of patch names.  They must be "zip" files.  Do not include the .zip extension.
                string patchNames = RoleEnvironment.GetConfigurationSettingValue("patches");

                if (patchNames.Length > 0)
                {
                    PatchAzure.Patch(accountName, key, patchContainer, patchNames, rootdir);
                }
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.Message);
            }

        }
		...

Listing 2

ServiceDefinition.csdef

ServiceDefinition\Webrole

...
    <ConfigurationSettings>
      <Setting name="patches" />
    </ConfigurationSettings>
 ...

ServiceConfiguration.csfg

ServiceConfiguration\ConfigurationSettings

...
<Setting name="patches" value="" />
...

Applying a Patch

Once the PatchAzure updates are deployed in your project, creating and applying a patch is easy.

1. Create a Zip file and give it a name ({name of patch}.zip).
2. Add files to the Zip file using the same directory structure as your web project.
3. You can include a batch file if you like and it will be run during the patching process. The name of the batch file must include the patch name and end in .cmd ({name of patch}.cmd).
4. Upload the Zip file to your Blob Storage Container. The container was specified in WebRole.cs (default=patches).
5. In the Windows Azure Portal, Click on your deployment. Then click Configure and edit your configuration file.
6. Locate the “patches” setting and add the patch name to the value attribute. The patch name must match the Zip file name that you uploaded (without the .zip extension).

   

   Example:

     <Setting name="patches" value="patch1,patch2,patch3" />
   

7. When you click OK, the configuration file will save. This will trigger the application of the patches.
8. The Zip file is downloaded from blob storage to each web instance. The files are extracted to their appropriate locations and then the Zip file is renamed to indicate that the patch is complete.

Could this process be used in production (perhaps even for an xcopy site update)? That’s up to you, but I think it’s possible. One thing that might make this unworthy of production is the lack of feedback. It is difficult to tell if a patch succeeds, so be prepared to use Remote Desktop. The code could be improved to provide more feedback, but much of that may depend on your needs.

I’ve tested this process and it’s been working for me, but I haven’t been using it long. Please let me know if you find any issues or have suggestions. As for me, I’m happy to finally have an easier way to fix my typos.

Code–> AuthPack on GitHub

Most of the code comes from the standard Web Forms project template. I wove in the authentication code which uses Forms Auth without an auth provider. You’ll need to add your own business logic and error handling, but it’s a good start.

I wish I had more time to create an elegant visual interface for the buttons, but maybe someone else will provide an update.

There is also a BSD-style license attached, which means you can do what you want with it, but please leave the copyright notice intact. That seemed to come up a few times with the old code where people weren’t sure if they could use it or not. A funny thing happened while I was researching code for LinkedIn. It seems that Fatih repackaged my Twitter work as his own work on LinkedIn. Dude, at least change the comments.

Oh how I wish I could have asked them if they’d ever watched “Undercover Boss” and then revealed myself as the CEO.  That would have been fun.  But now that I think about it, since Amtrak is government owned, I really am the boss.  Besides paying taxes for that railroad, I paid a lot of money to ride that train, and I deserve a minimum amount of respect.  

The story that I linked to in the first paragraph mentions that Amtrak is subsidized by the government and actually loses money with each rider.  Keeping that in mind, maybe they’re trying to turn us away.  If that’s the strategy, I suppose it worked for me.  I’ll drive next time.  I have to warn them though, now that I’m aware of the Amtrak subsidies, I’ll be voicing my opposition to extending their funds. 

With taxpayer support hanging in the balance, you’d think Amtrak would be working harder to make sure that every passenger had the best experience possible.  Basic manners and a courteous attitude really shouldn’t cost them anything, but the absence of decent customer service could cost them everything.

With .NET development, I seem to be challenged more often lately, and the latest challenge comes in the form of a “guidance” project called Project Silk.  I enjoy a good challenge, but I also wonder, “Is this new methodology worth learning? Will this particular strategy stick?”  For example, wasn’t Microsoft’s Atlas project supposed to tie ajax development into the Visual Studio toolset?  Luckily, I sort of ignored Atlas and continued to code my own ajax code by hand (with jQuery).  Now, it appears that Atlas is a thing of the past and Microsoft (through Project Silk) is recommending a different technique (interestingly enough, using jQuery).  Always up for a good challenge, I decided to dive into this project and try to learn the new techniques. 

If you’re short on time, I’ll provide my quick analysis of Project Silk.  As a web project, it’s a beautiful example of what can be done with .NET using modern programming techniques.  However, as a learning tool, it is unnecessarily complicated and may just be a waste of your time.

Model View Controller (MVC)

So why do I think Project Silk is overly complicated?  Number one, it’s built using MVC3 (the third release of Microsoft’s Model View Controller pattern).  MVC is an alternative to Web Forms, and while I do like some of its features, in general, the MVC constructs and its abstract implementation are difficult to use.  I admit that I’ve only done a bit of programming with MVC, mainly because I have to relearn it every time I look at it.  The terms “Model View Controller” just don’t stick in my mind.  I’d love to hear what other developers think of MVC.  Although I consider myself a decent programmer, I shun some of the complexity that other engineers seem to relish.   

MVC separates the traditional web application into smaller components.  One of the biggest advantages is that it makes testing much easier.  But I’ve seen this approach before with COBOL. (If you’ve ever worked with PeopleSoft COBOL, you know what I mean.)You can componentize everything to the point that it takes forever to trace a bug; you can’t see what the overall program is doing because it’s so difficult to follow the code through each component.  It’s also very difficult to add new code.  This sort of programming creates beautiful trees but unnavigable forests.

Patterns should be communicated in simple terms, even when the implementation is complex.  I don’t think that has been done with MVC.  For me, MVC takes simple web concepts that we all understand and turns them into abstract words that have little meaning in the real world.  For example, the Controller in the Model View Controller Pattern is really just a page.  Now, some people will argue with me on that, but it’s the easiest way to understand it.  The Controller is responsible for handling the web request and response (whatever it may be – HTML or data).  That’s a web page.

For example, the Controller in the Model View Controller Pattern is really just a page.

The Model in the MVC pattern should have been called Data Class.  That’s all it is.  It’s a way to represent data in a class instead of referring directly to the SQL tables.  I like that Microsoft allows you to create a table from the class definition, but I’m not thrilled about the requirement to keep them in sync.  There is also a scary feature where it will automatically drop and recreate tables that aren’t in sync with the code.  Yikes!

The View is a template, usually an HTML template.  Recently, Microsoft invented a whole new templating system called Razor, which is also promoted in Project Silk.  I’m not thrilled with Razor either.  Razor has its own syntax.  Do we really need one more thing to learn?    What I do like about Razor is that they gave it a good name.  I can remember that.

jQuery

Then we come to jQuery.  How is Microsoft using jQuery in Project Silk?  I was hoping that they would deliver something that would elegantly tie jQuery in to ASP.NET.  Unfortunately, the Project Silk code demonstrates techniques that many people have been using for a few years.  The jQuery usage is smart, but it’s very specific to this project.  To take advantage of Project Silk, you’d have to learn how to create jQuery widgets, and you’d have to learn how to add them into your project.  Microsoft had an opportunity to streamline the business of dynamic UI creation, but they didn’t try.  They took the easy way out.  “Here’s how you can do this, if you have the time to learn all of these different tools and understand how it all fits together.”  If you are a team of one, like I am, good luck.

Suggestions

But rather than just list my complaints, I’ll offer suggestions to make this more approachable for people like me.

Simplify MVC (Change the name too!) – Rename “Model” to Data Class.  Refer to Controllers as Page Controllers.  Views are okay, I suppose, but Templates make more sense.  Group the templates with the page controller, like (you guessed it) a code-behind.  Yes, a lot of these suggestions are semantic changes, but that is one of the biggest issues with MVC.

Innovate with jQuery – jQuery is a great library.  How can we take advantage of it in .NET without having to write jQuery widgets?  Microsoft could deliver standard jQuery widgets that we can all use within our templates.  For example, why is the data widget in Project Silk named “mstats.data.js?”  Can this be a standalone widget that can be reused in any project?  It looks like it, but that should be spelled out with better examples.  I like the way Project Silk uses widgets, but that use should be taken to the next level so that developers don’t have to worry about learning one more coding detail.

Evolve What We Know – Microsoft didn’t need to create Razor.  What other things could be done to give us the same benefits?  We could have improved the web forms pages to include similar features without introducing new syntax.  How about C# scripting?  I’m not talking about replacing javascript, but what if a new library was introduced to save scripting steps?  For instance, let me insert a C# command to generate jQuery ajax code:

<% 

if (jQueryAjax("/someurl"))

{

    jQueryAjaxSuccess();

} else {

    jQueryAjaxError();

}

%>

Now something like that would be easy to understand, save me a ton of time, and reduce the amount of new things that I need to learn. 

Conclusion

There are a lot of smart people working on solutions at Microsoft, and I admire the work they do, but sometimes I feel like they’re too smart for their own good.  MVC is a great example.  It’s an interesting pattern, but maybe you should talk with the man-in-the-street before muddying up the waters with yet another programming approach.  Now, we’re left with more questions than answers when it comes to figuring out which tools to use and which direction to head.

We need a single set of simple tools to help us develop great web applications.  While Project Silk is a nice example of what can be done, It doesn’t go far enough to improve on how things should be done.

I had just read Reed Hastings infamous mea culpa/new service announcement, and, coincidentally, I had some time to kill.  While grousing on Twitter about the seemingly absurd Netflix changes and reading the thousands of comments on the Netflix blog, I developed an urge to watch an instant movie.

I’m a sci-fi fan and I had watched the original Omega Man on Netflix a few months ago.  That led me to an interest in I Am Legend (Will Smith’s remake of Omega Man).  I looked up I Am Legend, but it’s not available to watch instantly.  That’s okay, there are plenty of other movies in the Netflix catalog.  I had always been curious about, The Village by M. Night Shyamalan.  Hmmm, that’s DVD-only too.  Okay, I’m still thinking about an M. Night flick, how about Lady in the Water?  DVD-only.  Okay, I was getting a little frustrated.  I recalled a Denzel Washington movie that I had missed, called Unstoppable.  I looked it up and read the summary.  That sounded perfect, but it’s only on DVD.  I gritted my teeth.  Maybe Unstoppable is too recent.  How about The Manchurian Candidate? Once again, DVD only.  I went through several other movie titles and none of them were available to watch instantly.  By the end of my search I had used up all of my free time and had to go to bed.

I enjoy Netflix streaming, but my family will tell you that I watch a lot of “crap” on it.  Streaming may be the future, but I guess, for now, I’m more of a Qwikster customer…or not.

I use the .NET Serialization Library to deserialize JSON (which is what the G+ API returns). Since I already mapped the person JSON to a class, I thought I’d share the code here and save someone a bit of time. The .NET library from Google doesn’t support G+ yet, but this is working for me right now.

#region Notes
/*
* Author: Shannon Whitley – http://voiceoftech.com/
* Date: 9/16/2011
*/
#endregion
using System.Runtime.Serialization;

namespace yournamespace
{
[DataContract]
public class GPlusPerson
{
[DataMember]
public string kind { get; set; }
[DataMember]
public string id { get; set; }
[DataMember]
public string displayName { get; set; }
[DataMember]
public name name { get; set; }
[DataMember]
public string nickname { get; set; }
[DataMember]
public string tagline { get; set; }
[DataMember]
public string birthday { get; set; }
[DataMember]
public string gender { get; set; }
[DataMember]
public string aboutMe { get; set; }
[DataMember]
public string currentLocation { get; set; }
[DataMember]
public string relationshipStatus { get; set; }
[DataMember]
public string url { get; set; }
[DataMember]
public image image { get; set; }
[DataMember]
public value_type[] emails { get; set; }
[DataMember]
public value_type[] urls { get; set; }
[DataMember]
public organizations[] organizations { get; set; }
[DataMember]
public value_type[] placesLived { get; set; }
[DataMember]
public string[] languagesSpoken { get; set; }
[DataMember]
public bool hasApp { get; set; }
}

[DataContract]
public class name
{
[DataMember]
public string formatted { get; set; }
[DataMember]
public string familyName { get; set; }
[DataMember]
public string givenName { get; set; }
[DataMember]
public string middleName { get; set; }
[DataMember]
public string honorificPrefix { get; set; }
[DataMember]
public string honorificSuffix { get; set; }
}

[DataContract]
public class image
{
[DataMember]
public string url { get; set; }
}

[DataContract]
public class value_type
{
[DataMember]
public string value { get; set; }
[DataMember]
public string type { get; set; }
[DataMember]
public bool primary { get; set; }
}

[DataContract]
public class organizations
{
[DataMember]
public string name { get; set; }
[DataMember]
public string department { get; set; }
[DataMember]
public string title { get; set; }
[DataMember]
public string type { get; set; }
[DataMember]
public string startDate { get; set; }
[DataMember]
public string endDate { get; set; }
[DataMember]
public string location { get; set; }
[DataMember]
public string description { get; set; }
[DataMember]
public bool primary { get; set; }
}

}