dougv.com « Doug Vanderweide » REST

Displaying Selected YouTube Data API Thumbnails On A Web Page Via ASP.NET Web Forms

Doug Vanderweide — Thu, 15 Mar 2012 23:37:41 +0000

Previously, I blogged about “Displaying Selected YouTube Video Thumbnails On An ASP.NET Web Forms Page,” when you know the video IDs of the thumbnails you want to hyperlink.

A reader recently asked me how to hyperlink YouTube video thumbnails based on searching for a keyword. I promised to address that, so here goes.

Interestingly enough, searching the YouTube Data API is accomplished in a REST-like manner quite similar to the methodology I used for shortening URLs in ASP.NET via the bit.ly API.

Form a simple request URL to the YouTube Data API that contains the appropriate search parameters;
Use a WebRequest to send that URL to Google, which returns an XML document with results;
Use WebResponse to dump that stream into an XmlDocument;
Use XPath and XmlNode‘s SelectNodes method to recursively get the thumbnails from each entry; and
Bind up a pile of Hyperlink controls, which are added dynamically to a Panel control.

Sounds more complicated than it actually is. Let’s do it.

Overview Of The YouTube Data API

First step in leveraging the YouTube Data API: Get a Youtube Data API developer key.

As of this writing, you can keyword search query the YouTube Data API without supplying a developer key and get a useful response. However, Google wants you to supply a key, and a time may come where you must supply one. So take the 30 seconds required to register a key.

With our developer key in hand, we can proceed to build a simple keyword query. In this case, we’re going to get the top 12 videos that meet the search criteria “Miss Maine.”

For our purposes, “top 12 videos” means the 12 videos YouTube deems most relevant to the exact search term “Miss Maine.” In other words, our search is going to work exactly as though we had typed “Miss Maine” (including the double quotes) into the search box at youtube.com; the results we get back should be the same as the first 12 results we would get via a default search on youtube.com. (For the usual vague reasons, this won’t always be the case, but the results sets will be similar.)

The YouTube Data API tells us that, to do a search query, we can GET a request to its servers, with our search parameters as querystring variables, and Google will return to us an XML document containing records that match our query.

Because we’re not requesting user-specific data, we don’t need to authenticate our requests; as previously mentioned, we don’t even need to send along our developer key. (But, again, being courteous and thorough, we will send it, as requested.)

So, the methodology we use to get our records is exactly the same as we used to shorten a URL via the bit.ly API; we’re going to create a URL containing all our parameters, then make a WebRequest to the YouTube Data API; we’ll get its returned XML via a WebResponse, and push that into an XmlDocument, from which we can extract the information we want.

As we build this solution, let’s keep some non-technical things in mind:

Many of the videos on YouTube aren’t very good, in the aesthetic, intellectual or civil senses. In other words, much of what is on YouTube is terrible.
A sizable number of YouTube videos are spam.
It’s de rigueur to keyword spam video descriptions, especially if the video is spam.
Trolling is mandatory for YouTube video comments, and you’ll probably be linking directly to that.

We can mitigate the damage, somewhat, by applying the smartSearch filter, being very specific with our search term, including specific words we don’t want returned in our results, restricting the categories in which we want to search … in other words, being as specific as we can about what we want to see.

However, I’ll bet a dollar to doughnuts that if you request any sizable result set on any generic search term, your results set is going to contain items you wish weren’t in there. That’s just the nature of the thing, and there’s little that can be done about it.

Querying The YouTube Data API

There are three distinct phases in our solution: query the API, get the information we need from its response, and put that information on the page. Therefore, we will use three distinct functions and subroutines to do the work.

First up, a function to submit our query. It accepts as arguments our developer key and a formatted querystring, and it puts the response into an XML document for us. If the request fails, it will report as much in a Label control, and return an empty XML document.

Function QueryYouTubeDataAPI(ByVal strAPIKey As String, ByVal strQuery As String) As XmlDocument
	'Returns empty XMLDocument on failure, results XML on success
	'This function requires your page to have a label control named lblStatus for error reporting

	'build URL to shorten method resource
	Dim strUri As New StringBuilder("https://gdata.youtube.com/feeds/api/videos?")
	strUri.Append("v=2")
	strUri.Append("&")
	strUri.Append(strQuery)
	strUri.Append("&key=")
	strUri.Append(Server.HtmlEncode(strAPIKey))
	strUri.Append("&prettyprint=true") 'adds line breaks & white space to response; useful for debugging

	Dim objRequest As HttpWebRequest
	Dim objResponse As WebResponse
	Dim objXML As New XmlDocument() 'This is the document the function will return

	Try
		'create request for shorten resource
		objRequest = WebRequest.Create(strUri.ToString)
		'since we are passing querystring variables, our method is get
		objRequest.Method = "GET"
		'act as though we are sending a form
		objRequest.ContentType = "application/x-www-form-urlencoded"
		'don't wait for a 100 Continue HTTP response
		objRequest.ServicePoint.Expect100Continue = False
		'since we are using get, we need not send a request body; set content-length to 0
		objRequest.ContentLength = 0

		'read the Data API response into XML document
		objResponse = objRequest.GetResponse()
		objXML.Load(objResponse.GetResponseStream())
	Catch ex As Exception
		lblStatus.Text = "Error querying YouTube Data API. Message: " & ex.Message
	End Try

	'send XML Document
	Return objXML
End Function

A note about error trapping: The error trapping I have used here does not check whether or not the YouTube Data API returns a sensible result. It only checks that we formed a request and the API responded.

If there is a problem with the query string you send to the YouTube Data API, or your request is somehow malformed, the API will return to you the 25 most popular videos for the day, as of the time of the request.

You can check to see if the YouTube Data API is seeing your request properly by looking for the /feed/link rel=’self’ node:

If the URL in that node doesn’t resemble the one you sent, most likely your querystring is malformed; but possibly, there are other errors in your request URL.

Creating The Query String

You’ll notice that I am not very specific about the query string argument passed to the previous function. That’s because I want to give you maximum flexibility, and the best way to do that is to allow for a free-form query string to be supplied.

So let’s look at how I’ll build my sample query string. I’ll do that, of course, with key-value pairs. That is, I will specify the parameter I want to send, and set it as equal to something.

First up, the search term. We’re going to use “Miss Maine.” So, the first part of our query string is:

q="Miss Maine"

Note that the YouTube Data API says all parameters should be URL encoded. Our function will take care of that for us when we create the WebRequest, so don’t bother encoding your query string in advance, or you’ll get errors. Just pass it to the function as natural text.

Technically, we can stop here and let the default API request variables take over. But I want to be more specific about my search results, so let’s add some more parameters.

Next, I’ll limit my responses to 12 records, by appending that key-value pair to my string:

q="Miss Maine"&max-results=12

I’d like only short (under 4 minutes) videos:

q="Miss Maine"&max-results=12&duration=short

To cull at least some offensive material, I’ll use strict safeSearch:

q="Miss Maine"&max-results=12&duration=short&safeSearch=strict

Finally, I’m going to specifically ask for English language videos that best match my search term. So my completed query string is:

q="Miss Maine"&max-results=12&duration=short&safeSearch=strict&orderby=relevance_lang_en

You may be wondering why I am not using the GData .NET Library to accomplish this search. That’s an excellent option in general, but it involves installing components on your local machine and Web server.

For many Web developers, adding DLLs to a Web server or installing assemblies on a workstation can be problematic, if not prohibited outright. So I want to use as many built-in resources as possible. However, if you can install the GData API, consider going that route.

Examining The XML Response

Assuming our request goes through — that is, our Web server actually delivers the request to YouTube, which in turn sends a response back — we now have an XML document in storage that contains the information we requested. (Or, in the event of a malformed request, the default results set previously described.)

You can see the XML document returned for my demo query string here: http://www.dougv.net/demos/youtube_data_api_thumbs/videos.xml

In our case, we want some specific data for each video:

Its title;
the default thumbnail; and
the URL to its player page on youtube.com.

We get back lots more useful information in the XML response: The name of the uploader, the run time of the video in seconds, its likes and dislikes count, the categories and keywords assigned to the video, the date and time it was uploaded, its view count, etc. But for this solution, we’ll only use the video’s title, thumbnail and URL.

Although the actual XML document contains much more data per entry, for our purposes, the relevant structure of the document looks like this (I’ve stripped out extraneous attributes):

In practice, the parts of an entry (that is, an individual record) that we want to use look like this:


	Miss Maine USA 2011

Traversing The XML Response Document

There are a number of ways in ASP.NET to traverse / select nodes from an XML document.

The way most Web resources will tell you to do it is with LINQ to XML. LINQ allows us to make a SQL-like query of the XML document, and receive in return a SQL-like recordset, which we can then use to ouput our data.

LINQ to XML is definitely the way to go if you’re going to work with a large XML document, or need to extract data in a very complicated way (e.g, get various node attributes; select nodes based on data contained in other nodes).

LINQ to XML would work here, too, but I think it’s a bit of overkill, considering we only need three values from 12 records. So I’m just going to use the built-in parsing functions that are part of XmlDocument, a class we have already encumbered. Also, I’m more used to using XPath than I am LINQ.

Another way is to create an XML Stylesheet (XSLT) which will “flattened out” the XML document into 12 nodes (each representing one record) with three attributes (each representing the title, URL and thumbnail for that record). I describe that methodology at “Using National Weather Service XML Feeds With ASP.NET, ADO.NET And XSL.”

But I am trying to limit the number of things you have to learn at one time to accomplish this task. In my estimation, it’s a bit easier to hack together an XPath expression than to write an XSLT, so this is how I’m proceeding.

We’ll need three XPath expressions that will give us, for each of the 12 videos returned:

the inner text of title,
the inner text of the link node that has the attribute ‘alternate’, and
the url attribute of whichever media:thumbnail node that has the additional attribute of yt:name=’default’.

The XML returned by the YouTube Data API uses several namespaces (atom, media, yt, etc.). Therefore, we first have to make reference to those namespaces in order to traverse the response XML.

We do that by creating an XmlNamespaceManager, then adding the specification URLs to it:

'add namespaces so we can traverse this thing
Dim xmlNSM As New XmlNamespaceManager(xmlDoc.NameTable)
xmlNSM.AddNamespace("atom", "http://www.w3.org/2005/Atom")
xmlNSM.AddNamespace("media", "http://search.yahoo.com/mrss/")
xmlNSM.AddNamespace("yt", "http://gdata.youtube.com/schemas/2007")

(We got these URLs from the root (“feed”) node’s attributes. That’s where they always appear, any time an XML document references namespace(s).

An XML namespace is basically a description of what elements an XML document will have, the kinds of data each node will contain, and other useful technical information that helps a parser understand what it is looking at and how to consume it.

Now that we have the namespaces referenced, we can go ahead and create our XPath arguments. Here they are:

'let's get our entry node values
Dim xmlTitleNodes As XmlNodeList = xmlDoc.SelectNodes("/atom:feed/atom:entry/atom:title", xmlNSM)
Dim xmlURLNodes As XmlNodeList = xmlDoc.SelectNodes("/atom:feed/atom:entry/media:group/media:player", xmlNSM)
Dim xmlThumbNodes As XmlNodeList = xmlDoc.SelectNodes("/atom:feed/atom:entry/media:group/media:thumbnail[@yt:name='default']", xmlNSM)

Note that I use the namespace:node syntax to select the nodes I want. If I didn’t do that, the XML parser wouldn’t understand what I meant if I said simply, “feed”, for example. I have to let the parser know which namespace the element “feed” belongs to, so it can find it.

With our nodes on hand, we just need to iterate each XmlNodeList, get our values, and pass them to a subroutine that adds hyperlinked thumbnails to our page.

We can use a simple For loop here, because by design, the number of title, thumbnail and hyperlink nodes will be the same, and the nodes will be in the same order in all three XmlNodeLists. (That is, the first node in each XmlNodeList will be for the first record; the title, URL and thumbnail values will match up, because they were listed in order in the XML document.)

'For loop will iterate them; by definition, counts are the same for each XmlNodeList
For I = 0 To xmlTitleNodes.Count - 1
	strTitle = xmlTitleNodes.Item(I).InnerText
	strURL = xmlURLNodes.Item(I).Attributes("url").Value
	strThumb = xmlThumbNodes.Item(I).Attributes("url").Value

	CreateHyperlinkedThumb(strTitle, strURL, strThumb)
Next

Here’s what the entire subroutine looks like:

Sub MakeThumbnailLinks(ByVal strAPIKey As String, ByVal strQuery As String)
	'create XML document we will parse
	Dim xmlDoc As New XmlDocument()
	xmlDoc = QueryYouTubeDataAPI(strAPIKey, strQuery)

	'add namespaces so we can traverse this thing
	Dim xmlNSM As New XmlNamespaceManager(xmlDoc.NameTable)
	xmlNSM.AddNamespace("atom", "http://www.w3.org/2005/Atom")
	xmlNSM.AddNamespace("media", "http://search.yahoo.com/mrss/")
	xmlNSM.AddNamespace("yt", "http://gdata.youtube.com/schemas/2007")

	'let's get our entry node values
	Dim xmlTitleNodes As XmlNodeList = xmlDoc.SelectNodes("/atom:feed/atom:entry/atom:title", xmlNSM)
	Dim xmlURLNodes As XmlNodeList = xmlDoc.SelectNodes("/atom:feed/atom:entry/media:group/media:player", xmlNSM)
	Dim xmlThumbNodes As XmlNodeList = xmlDoc.SelectNodes("/atom:feed/atom:entry/media:group/media:thumbnail[@yt:name='default']", xmlNSM)

	'for debugging, we'll also get the url that represents what the Data API actually used
	Dim objNode As XmlNode = xmlDoc.SelectSingleNode("/atom:feed/atom:link[@rel='self']", xmlNSM)
	lblStatus.Text = "Request URL returned by YouTube Data API: " & Server.HtmlEncode(objNode.Attributes("href").Value)

	'strings to store values
	Dim strTitle As String
	Dim strURL As String
	Dim strThumb As String

	'looping variable
	Dim I As Integer

	'For loop will iterate them; by definition, counts are the same for each XmlNodeList
	For I = 0 To xmlTitleNodes.Count - 1
		strTitle = xmlTitleNodes.Item(I).InnerText
		strURL = xmlURLNodes.Item(I).Attributes("url").Value
		strThumb = xmlThumbNodes.Item(I).Attributes("url").Value

		CreateHyperlinkedThumb(strTitle, strURL, strThumb)
	Next
End Sub

Creating Thumbs From Results

The CreateHyperlinkedThumb subroutine takes the title, URL and thumbnail strings we got, applies them as properties to a Hyperlink control, and adds those controls to a Panel on our page.

Sub CreateHyperlinkedThumb(strTitle As String, strURL As String, strThumb As String)
	'create hyperlink
	Dim ctlLink As New HyperLink()

	'set values
	ctlLink.Text = strTitle
	ctlLink.ToolTip = strTitle
	ctlLink.NavigateUrl = strURL
	ctlLink.ImageUrl = strThumb
	ctlLink.CssClass = "margin-5"
	ctlLink.Target = "video"

	'add to panel
	pnlThumbs.Controls.Add(ctlLink)
End Sub

And with that, we’re done!

To invoke, we simply call the MakeThumbnailLinks subroutine, passing to it our YouTube Data API developer key and the querystring we built:

MakeThumbnailLinks("YOUTUBE_DATA_API_DEVELOPER_KEY", "q=""Miss Maine""&max-results=12&duration=short&safeSearch=strict&orderby=relevance_lang_en")

You can see a working demo here: http://www.dougv.net/demos/youtube_data_api_thumbs/Example2.aspx

The code for this solution, as well as “Displaying Selected YouTube Video Thumbnails On An ASP.NET Web Forms Page,” can be downloaded here: http://www.dougv.com/wp-content/uploads/2012/03/youtube_data_api_thumbs.zip

All links in this post on delicious: http://delicious.com/dougvdotcom/displaying-selected-youtube-data-api-thumbnails-on-a-web-page-via-asp-net-web-forms

The numbers inside parentheses are relevance scores. Scoring is based, in order of priority, on title, category, content and tags. The higher the score, the more likely that post relates to this post.

Tags: bit.ly, Google, Microsoft, REST, RSS, XPath, XSLT

Getting QueryString Values From A Rewritten URL / ASP.NET Routing URL

Doug Vanderweide — Fri, 10 Dec 2010 03:15:51 +0000

During today’s similcast of the ASP.NET Firestarter in Atlanta, G. Andrew Duthie discussed .NET 4′s new support for routing — or, what everyone in Web development calls “URL rewriting.” *

Someone online asked, “If I use routing, can I access query string variables using JavaScript?”

The question isn’t as confused as it sounds on the surface. Of course, if one uses routing / URL rewriting, it’s to remove query string variable and make them part of what appears to be a permanent file structure.

In other words, this:

http://www.server.com/path/to/file.aspx?v1=foo&v2=bar

Becomes this:

http://www.server.com/path/to/file/v1/foo/v2/bar/

The questioner really means, is there a way, after rewriting a URL, to extract key->value pairs from it via JavaScript? The answer is yes; rather than using the location.search property, which allows JavaScript to get the querystring parameters of a URL, we use location.pathname to get the part of the URL that follows the domain, and use that to create our key->value pairs.

In the case of query strings, one can, in JavaScript, use location.search to get query string pairs from the current URL.

alert(location.search);

If we invoke this JavaScript on the first URL, we get the entire query string, including the question mark:

Then, to get the key-value pairs, we’d simply strip off the leading question mark, then split the remaining string into an associative array, like so:

//get key->value pairs
var qs = location.search;
qs = qs.substring(1);
var a = qs.split('&');

var b;
var i;
var output = new Array();

for(i = 0; i < a.length; i++) {
	//split each key->value pair
	b = a[i].split('=');
	//add each pair to output array
	output[b[0]] = b[1];
}

Of course, we can’t use location.search to get query string variables if we’ve made those variables part of the file path, as in a URL rewrite / Routing. We get a null string if we try:

But we can use location.pathname to get the URL to our file, and modify our JavaScript to create key->value pairs from that URL:

//get key->value pairs from URL
var qs = location.pathname;
//strip leading path slash
qs = qs.substring(1);

var a = qs.split('/');
var i;
var output = new Array();

for(i = 0; i < a.length; i += 2) {
	//append key->value pairs to output array
	output[a[i]] = a[i + 1];
}

Alternative: A URL That Does Not Begin With Key->Value Pairs

The example above assumes that we have a URL patterned specifically after key-value pairs, and that those pairs begin at the start of the URL. In other words, the above rewritten / routed URL and JavaScript would create an array like:

output['v1'] == 'foo';
output['v2'] == 'bar';

So we’d need to modify this JavaScript if the rewritten / routed URL does not begin immediately with key->value pairs. For example, suppose this is our rewritten URL:

http://www.server.com/store/category/toys/type/dolls/maker/mattel/

In this case, let’s suppose that “store” isn’t part of the key->value chain we want. Or, to make it plainer, if we were using a query string, this is how the URL would look:

http://www.server.com/store.php?category=toys&type=dolls&maker=mattel/

In that case, we’d need to adjust our for loop to skip over “store,” since it isn’t relevant to the key->value pair extraction. We can do that quite easily by simply starting the for loop at 1, rather than zero:

//get key->value pairs from URL
var qs = location.pathname;
//strip leading path slash
qs = qs.substring(1);

var a = qs.split('/');
var i;
var output = new Array();

for(i = 1; i < a.length; i += 2) {
	//append key->value pairs to output array
	output[a[i]] = a[i + 1];
}

If the URL looked like this:

http://www.server.com/site/store/category/toys/type/dolls/maker/mattel/

And “site” and “store” aren’t part of the key->value array we want to build, then we would start the for loop at 2, rather than 0.

Note that we can also end the for loop early, if the URL has trailing path information that shouldn’t be considered part of the key->values array.

Keyless Array

Another option here is to rewrite / route our URLs without keys.

Let’s look at the store URL sample, above. We know that we want to get values for category, type and maker. But probably every URL our JavaScript will process is always going to have those elements in the same order.

In other words, every URL that comes to our page is going to have category first, then type, then maker. So do we even need keys? Our URL could be much shorter and simpler if we eliminated them:

http://www.server.com/toys/dolls/mattel/

Our JavaScript is also much simpler: We can now use the initial split of the filepath variable.

//get key->value pairs from URL
var qs = location.pathname;
//strip leading path slash
qs = qs.substring(1);

var output = qs.split('/');
//output[0] == 'toys'
//output[1] == 'dolls'
//output[2] == 'mattel'

The Right Rewriting / Routing Rules Make A Big Difference

If you’ve chosen the proper URL rewrite / routing rules, you shouldn’t have to even work this hard to extract your former query string key->value pairs. The right pattern is key.

I distribute this code under the GNU GPL version 3.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/getting-querystring-values-from-a-rewritten-url-asp-net-routing-url

* Why Microsoft feels the need to re-brand common technologies is beyond me. It took them forever to adopt URL rewriting officially; and while “routing” is technically a correct description of what a rewrite engine does, it only makes it harder for developers to discuss patterns and practices with others when Microsoft insists on calling roses by other names.

Tags: Microsoft, REST, rewrite, SEO, Visual Studio, web server

MSDN Northeast Roadshow, Augusta, ME, May 11, 2010 Recap

Doug Vanderweide — Wed, 12 May 2010 20:23:36 +0000

After the nearly complete disappointment of Launch 2010 Boston, I had given serious thought to not going to the MSDN Northeast Roadshow stop in Augusta, ME on Tuesday, May 11. I figured it would be little more than a regurgitation of what happened at last month’s event.

I’m glad I decided to go. What a huge difference.

In half the time, Jim O’Neil and Chris Bowen provided immeasurably more valuable and interesting information about Visual Studio 2010 and changes to Silverlight, multithreading, ASP.NET and an overview of Windows Phone 7. Here’s a recap.

Jim O'Neil describes Silverlight 4's new video / webcam support features.

Silverlight 4: Lately, listening to Microsoft describe a new Web technology brings to mind the phrase “a day late and a dollar short.” That’s certainly the case with Silverlight 4.

Admittedly, Microsoft has shifted the emphasis behind Silverlight to be less a clone of Flash and more an extension to the Web of Windows Presentation Foundation. But the “new features” O’Neil described on Tuesday were very much old technologies for Flash, and pretty much obsolete tech given HTML5.

Specifically, Silverlight 4 supports Web cams and microphones; TCP/UDP; printing; and a multiple-trust-level model that includes access to the file system, cross-domain requests and COM integration. Additionally, the XAML one writes to render Silverlight, while still different from WPF XAML, is a lot more like WPF.

Silverlight is, therefore, weaker than Flash and stronger than it at the same time. But it seems mostly moot, given that Flash itself is falling out of favor in response to the HTML5 specification’s API support for audio, video and other complex objects. Admittedly, there are things one can do in Silverlight — namely, presenting stored data and integrating existing COM components, such as text-to-speech or an interface to a proprietary business object / program — that one cannot do directly in HTML5.

That seems to me more likely to matter when making a corporate intranet or the like. I didn’t see much hope for Silverlight when it was introduced in 2007, and I still don’t see a future for it.

Parallel Programming: I admit I’m not as up-to-speed as I should be with parallel programming, largely because 99 out of 100 things I program are Web apps. So maybe Bowen’s presentation on .NET 4′s revisions to multithreading aren’t that exciting, but I found them fascinating.

One of the most interesting things .NET does is employ local work-stealing queues. In other words, each thread can queue, specific to it, tasks to perform; but if a neighboring thread has nothing to do, it can reach into that other thread’s queue and process the job, too. Basically, that means optimizing each thread to work almost constantly, which is, of course, a wholesale improvement in processing efficiency.

A couple of neat tricks Bowen showed that can be easily integrated into a current .NET project are Parallel.For and Parallel.Invoke. Parallel.For effectively lets you multithread a standard for loop; Parallel.Invoke lets you multithread a series of method / function calls.

ASP.NET 4 and Windows Azure: Once again, I get the feeling that Microsoft is a bit behind the times when it comes to Web development technologies. And while integrating Azure, Microsoft’s cloud computing service, into Web development is pretty progressive, the rest of the improvements to ASP.NET, especially Web forms, is more fixing things that were broken than making things better.

Notable in ASP.NET 4 Web forms is the ability to disable viewstate at the page level, but enable it on a per-control level; previously, one could disable viewstate for a specific control while enabling it on the page level.

IIS 7 also more closely integrates the ASP.NET engine, so that services such as membership can be extended to plain HTML pages.

Web forms also has a slightly improved client-side naming convention for rendered controls, but in all honesty, it’s still a mess to address, via JavaScript, individual elements of, say, a GridView.

Dynamic Data sites are improved by adding EntityDataSource to the list of available data sources; and the MVC aspects of ASP.NET have been improved, although a lack of time prevented O’Neil from getting into them in detail.

He did have an opportunity to briefly go over using Azure to host both the application and data for a Web site, which looks interesting; but given how cheap Web hosting is, and that most Web apps can happily live on a shared hosting solution, or on a third-hand server that would otherwise be junked, I don’t see Azure Web programming being of much use to most folks.

Windows Phone 7: Due to previous presentations running long, Bowen ran short of time to talk about Windows Phone 7; I think “abortive” is a good one-word description of how this presentation went.

Fortunately, Windows Phone 7 won’t hit the market until Christmas time, so maybe he’ll get another crack at it before then. Until then, check out developer.windowsphone.com to get the tools (including an emulator), see tutorials, etc.

Swag And Final Thoughts: This event included the same T-shirt and VS 2010 Ultimate trial disc as Launch 2010 Boston, but an upgraded notebook and pen. I declined them. But I did win an awesome, insulated lunch bag at the end of the event:

The "Heroes Happen Here" lunch bag I won at the end of the May 11, 2010 MSDN Northeast Roadshow event in Augusta.

Note the “Heroes Happen Here” tag, which indicates this was a giveaway related to the VS 2008 / Windows Server 2008 / SQL Server 2008 launch. Oh, the irony.

I swear my shining opinion of this Roadshow event has nothing to do with winning the lunch bag. Statistically speaking, it was difficult not to win; I’d put the ratio of prizes to people at 4-1. The giveaways included two copies of VS 2010 Professional, several Windows mobile mouses, books, totes and other very cool stuff.

So yes, it’s nice to have won something cool (no pun intended), but it’s far better to have had my time rewarded with useful information. This event really renewed my faith in MSDN support for developers and took a lot of the sting out of the disappointment of Launch 2010 Boston.

Let’s hope Microsoft continues to support the Northeast Roadshow for a long time to come, because it is, by far, the most valuable resource I’ve found for learning about Microsoft tools and technologies.

Materials and Links: You can get the Powerpoints O’Neil and Bowen used at http://tinyurl.com/NERDShow0510. Eventually, screencasts will be available at http://code.msdn.microsoft.com/northeast.

I recommend joining the Northeast Roadshow’s Facebook group. But remember, group Wall posts aren’t included in your news stream, so you have to physically go to the group’s page to see what’s happening.

All links in this post on delicious: http://delicious.com/dougvdotcom/msdn-northeast-roadshow-augusta-me-may-11-2010-recap

Tags: Chris Bowen, cloud computing, coding standards, developer tools, IIS, Jim O'Neil, Microsoft, mobile, MSDN, productivity, REST, Sharepoint, Silverlight, Visual Studio, Windows Phone, Windows Server

Shortening URLs With The bit.ly API Via ASP.NET

Doug Vanderweide — Thu, 02 Jul 2009 04:25:27 +0000

After yesterday’s post on using the Twitter API to post status updates on Twitter from an ASP.NET application, a follower of my client suggested using a URL shortening service to link to the articles headlines being posted as tweets.

That was an excellent idea of which I should have thought in the first place. And thanks to the extreme simplicity of the REST-like bit.ly API, shortening URLs is as simple as sending a request URL laced with querystring variables.

So here is a quick and simple ASP.NET subroutine, written in VB.NET, to shorten URLs with the bit.ly API:

Sub BitlyIt(ByVal strUser As String, ByVal strAPIKey As String, ByVal strLongUrl As String)
	'This subroutine requires your page to have a label control named lblStatus

	'build URL to shorten method resource
	Dim strUri As New StringBuilder("http://api.bit.ly/shorten?")
	strUri.Append("version=2.0.1")
	'we want to get an XML response back from bit.ly, not the default JSON
	strUri.Append("&format=xml")
	strUri.Append("&longUrl=")
	strUri.Append(Server.HtmlEncode(strLongUrl))
	strUri.Append("&login=")
	strUri.Append(Server.HTMLEncode(strUser))
	strUri.Append("&apiKey=")
	strUri.Append(Server.HTMLEncode(strAPIKey))

	'create request for shorten resource
	Dim objRequest As HttpWebRequest = WebRequest.Create(strUri.ToString())
	'since we are passing querystring variables, our method is get
	objRequest.Method = "GET"
	'act as though we are sending a form
	objRequest.ContentType = "application/x-www-form-urlencoded"
	'don't wait for a 100 Continue HTTP response from bit.ly
	objRequest.ServicePoint.Expect100Continue = False
	'since we are using get, we need not send a request body; set content-length to 0
	objRequest.ContentLength = 0

	'we need to capture the XML being sent in response
	'read the response into a new XML document
	Dim objResponse As WebResponse = objRequest.GetResponse()
	Dim objXML As New XmlDocument()
	objXML.Load(objResponse.GetResponseStream())

	'the response will have three node values we're primarily interested in
	'the errorCode node will contain a numeric error code; 0 means success
	Dim nErrorCode As XmlNode = objXML.SelectSingleNode("//errorCode")
	'if there was an error, the errorMessage node will contain a user-friendly message useful for debugging
	Dim nErrorMsg As XmlNode = objXML.SelectSingleNode("//errorMessage")
	'if all went well, shortUrl will contain the full short URL created for our link
	Dim nShortUrl As XmlNode = objXML.SelectSingleNode("//shortUrl")

	'if we didn't get an errorCode value of 0, there was a problem; report the user-friendly message
	'on success, report the short URL for our resource
	If nErrorCode.InnerText <> "0" Then
		lblStatus.Text = "Error returned. Code: " & nErrorCode.InnerText & "; Message: " & nErrorMsg.InnerText
	Else
		lblStatus.Text = nShortUrl.InnerText
	End If
End Sub

Note the extensive similarity in shortening URLs with the bit.ly API to posting status updates with the Twitter API. That’s one of the many benefits of REST; the basic approach to retrieving, adding, updating and deleting data tends to be similar for all RESTful applications.

Aside: At some point, I plan to explain, in plain English, how REST works. It’s also worth noting that neither the Twitter nor bit.ly APIs are truly RESTful; that’s something I will explain in a future post. End of aside.

A few notes about the bit.ly API and the code above:

This code requires the System.Net, System.IO and System.Xml namespaces. Chances are, if you built your Web application in Visual Studio, these namespaces are already referenced in your web.config file.
This code should work for ASP.NET versions 1.1 forward.
As the comment on Line 5 states, by default the bit.ly API will return its response as JSON. In the case of server-side programming, it’s easier to work with XML, so we need to explicitly instruct bit.ly to respond with XML.
I use a StringBuilder to form the request URL in order to be very explicit about the components of the URL, especially in terms of from where its parts are drawn and what each part does. This is another case of choosing transparency over elegance. You can replace the StringBuilder with string concatenation if you want.
To authenticate yourself in the bit.ly API, you can either send your bit.ly username and your API key as querystring variables, or use basic HTTP authentication. I am using the querystring variables method for simplicity’s sake, but it is rather less secure than basic authentication. This would be more of a concern if we were using an AJAX solution that exposed both your username and API key directly to end users.
Your bit.ly API key can be found on your bit.ly account page (log in to the Web site and click the Account link in the upper right-hand corner). Do not send your bit.ly password when you attempt to authenticate via querystring; use your API key only. Don’t replace apiKey with password, don’t substitute your password for the apiKey value, etc.
Your long URL must be a fully qualified URL. For example, don’t send server.com/page.html, send http://www.server.com/page.html.
We need not set any content for our request; we’ll be sending everything we need to send via the header. Thus, we set the ContentLength property for the request to 0, so that bit.ly doesn’t sit around waiting for data that’s never coming.
In order to get back from bit.ly the shortened URL it creates, we need to capture the XML response it sends. In my previous tutorial about the Twitter API, my code pretty much ignored the returned XML, because I simply assume the tweet went through. If you want to take a more pessimistic view of tweeting via the API, you can use the same methods I use here to access return values.
Thankfully, when bit.ly responds via XML to a shorten request, it always sends the nodes errorCode, errorMessage and shortUrl, regardless of the success of the request. Even more fortunate for us, there are only one of each of those nodes in every response. Therefore, we can use a combination of the the SelectSingleNode method, and the XPath selector //{node} (where {node} is the local name of the node), to get the values contained in errorCode, errorMessage and shortUrl.
Once again, I am using a label with the ID of lblStatus to report the results of the request. You can change this code however you like to handle success or failure.
This time, I’m not using a try-catch block to see if there are problems with the request or response. You may find this code throws exceptions if you are sending bad querystring parameters, especially malformed longUrl parameters (for example, you send an incomplete URL as your longUrl value.) You can add a try-catch block if you want.

If you have a user name of foobar, an API key of R_bar123456abcd90876poi, and a long URL of http://www.helloworld.com, you would call this subroutine out-of-the box thus:

BitlyIt("foobar", "R_bar123456abcd90876poi", "http://www.helloworld.com")

The same methodologies I discussed in the Twitter API post for using a button, letting people shorten URLs with their own accounts via a form, storing your bit.ly account information in your web.config file, etc. all can be applied to this solution; I’ll trust that most people can adapt those methodologies to this code, but if there are requests to clarify, I will visit those tasks in the comments.

Finally, like the Twitter API, the bit.ly API has a rate limit; in this case, no more than five simultaneous connections.

In theory, your server should disconnect from the bit.ly API servers immediately after making its shorten request, but it is possible your server’s requests will be kept alive for whatever reason, and the ASP.NET garbage collector won’t come by quickly enough to clean them up. That’s highly improbable, so rate limits shouldn’t be an issue here.

Even so, again I am not posting a working demo. I have tested this code and it does work. I distribute all code under the GNU GPL version 3.

Tags: elegance, REST, XPath

Posting Status Updates (Tweets) To A Twitter Profile Via ASP.NET

Doug Vanderweide — Wed, 01 Jul 2009 05:03:24 +0000

Update, 16 Feb 2011: Please note that this routine will no longer work with the Twitter API. It is retained solely to prevent negative search engine rankings.

I have a client that posts several news stories to its Web site every day. So it makes tremendous sense for them to post the headlines to Twitter as tweets, so that followers might be informed of breaking news, or just what’s new on the site.

The Twitter API makes posting status updates (tweets) to Twitter as simple as invoking a WebRequest. Unfortunately, most of the ASP.NET examples on the Web that aim to show you how to post status updates are either written in C#, have coding errors, simply will not work, or all three.

So here’s a simple VB.NET subroutine that will post tweets.

Sub TwitIt(ByVal strUser As String, ByVal strPass As String, ByVal strMessage As String)
	'this subroutine requires your ASP.NET page to have a label control with an ID of lblStatus

	'create post variable for tweet
	Dim strTweet As String = "status=" & Server.HtmlEncode(strMessage)
	'convert post variable to byte array for transmission purposes
	Dim bRequest As Byte() = System.Text.Encoding.ASCII.GetBytes(strTweet)

	Try
		'create HttpWebRequest to status update API resource
		Dim objRequest As HttpWebRequest = WebRequest.Create("http://twitter.com/statuses/update.xml")
		'pass basic authentication credentials
		objRequest.Credentials = New NetworkCredential(strUser, strPass)
		'set method to post and pass request as a form
		objRequest.Method = "POST"
		objRequest.ContentType = "application/x-www-form-urlencoded"
		'tell the server it will not receive a 100 Continue HTTP response
		objRequest.ServicePoint.Expect100Continue = False
		'set content length of request
		objRequest.ContentLength = bRequest.Length

		'capture the stream (content) of the request
		Dim objStream As Stream = objRequest.GetRequestStream()
		'put the bytes into request
		objStream.Write(bRequest, 0, bRequest.Length)
		'close the stream to complete the request
		objStream.Close()

		'uncomment line below to report success
		'lblStatus.Text = "Tweet sent!"

		'You can also capture the XML response Twitter sends back
		'uncomment lines below to capture responses
		'Dim objResponse As WebResponse = objRequest.GetResponse()
		'Dim objReader As New StreamReader(objResponse.GetResponseStream())
		'lblStatus.Text = objReader.ReadToEnd()

	Catch ex As Exception
		'uncomment line below to report ASP.NET errors
		'lblStatus.Text = ex.Message
	End Try
End Sub

Update, July 19, 2009: I have moved the XML response block up into the try block, to avoid an error you will get if the API request returns an error. Thanks to Rob for noting this issue.

Some important notes about the code above:

This code requires the System.Net and System.IO namespaces. Chances are strong, if you used Visual Studio to create your Web application, those namespaces are already referenced in your web.config file.
This code should work for ASP.NET versions 1.1 and later.
Twitter prefers you use the OAuth protocol to authenticate your API requests and will eventually require it. However, they also say that they have not set a date at which they will no longer allow basic HTTP authentication requests. Since it’s far more concise, and generally secure enough, to use basic authentication, that’s what I am using here. Using OAuth to authenticate both requires you to get a key from Twitter and write about twice as much code.
The message you send is restricted to the standard length of a tweet (140 characters).
You need to set the Expect100Continue property (at Line 16) to false because otherwise, the HttpWebRequest will first send the request headers, then wait for a 100 HTTP status code from Twitter before proceeding with the body of the request (that is, the tweet). It will wait in vain; Twitter will not send a 100 Continue HTTP response; so Twitter will thus wait in vain for the rest of the message, unless you set Expect100Continue to false.
I have commented out several lines that set the text for a label ID’ed lblStatus. I always include such a label on my ASP.NET pages for debugging purposes. If you choose to uncomment those lines, remember to add a label to your ASP.NET page with the ID of lblStatus.
Every request to the XML version of the Twitter API will be answered with an XML reply that describes the results of the request. If you are having problems, consider uncommenting the code at the end of the subroutine to have the XML document echoed back to your page (and remember to add a label with the ID of lblStatus to your page).

This subroutine takes three arguments: Your Twitter username, your Twitter password, and the tweet. (Note that Twitter usernames and passwords are case-sensitive.) So, assuming your Twitter username is foobar, your password is barfoo, and your tweet is Hello World!, you would invoke the subroutine thus:

TwitIt("foobar", "barfoo", "Hello World!")

Suppose you want to have a form on your page that sends a user-supplied tweet to your Twitter account. The form would look like this:


	Enter your Tweet:

Your OnClick handler would be:

Sub btnSubmit_click(ByVal Sender As Object, ByVal E As EventArgs)
	TwitIt("foobar", "barfoo", tbTweet.Text)
End Sub

And you could also give people a gateway to post tweets to their own accounts:


	Enter your Twitter Username: 
	
	
	

	Enter your Twitter Password: 
	
	
	

	Enter your Tweet:

Sub btnSubmit_click(ByVal Sender As Object, ByVal E As EventArgs)
	TwitIt(tbUser.Text, tbPass.Text, tbTweet.Text)
End Sub

It’s important to note that there are usage limits for the Twitter API; if you run an open application that lets people post tweets from your Web site, there’s a strong chance your site will be blacklisted by Twitter for exceeding the API rate limits.

Or, you could also add your Twitter username and password to your web.config file, remove them as arguments to the TwitIt() function, and just pass along the tweet as an argument:

Sub TwitIt(ByVal strMessage As String)
	Dim strTweet As String = "status=" & Server.HtmlEncode(strMessage)
	Dim bRequest As Byte() = System.Text.Encoding.ASCII.GetBytes(strTweet)

	Dim objRequest As HttpWebRequest = WebRequest.Create("http://twitter.com/statuses/update.xml")
	objRequest.Credentials = New NetworkCredential(ConfigurationManager.AppSettings("TwitterUsername"), ConfigurationManager.AppSettings("TwitterPassword"))
	objRequest.Method = "POST"
	objRequest.ContentType = "application/x-www-form-urlencoded"
	objRequest.ServicePoint.Expect100Continue = False
	objRequest.ContentLength = bRequest.Length

	Dim objStream As Stream = objRequest.GetRequestStream()
	objStream.Write(bRequest, 0, bRequest.Length)
	objStream.Close()
End Sub

And that’s all there is to it. I don’t have a working example (because of the API rate limits) but I have tested this code and know it works. I distribute all code under the GNU GPL version 3.

Tags: elegance, REST

Most Code Downloads Restored; Some Articles Deleted

Doug Vanderweide — Wed, 03 Jun 2009 15:47:10 +0000

I’ve restored about two-thirds of the code downloads on the site, especially for the most popular articles on this site. I’ve also had to delete some articles that were either based on images I can no longer locate or were, to be blunt, badly written.

Bear with me; I should have the last of the code downloads reinstated over the next few days.

Also, be aware that certain trackback / inline links on this site may now be dead, as a result of the aforementioned post prunings.

My Experience Getting A Code Signing Certificate From Comodo (10.6)
Downloadable Code, Images Gone (10.4)

Tags: REST

Describing ‘Red’ To A Blind Man: The Dilemma Of Ontology

Doug Vanderweide — Thu, 04 Sep 2008 03:40:45 +0000

Recently asked on Yahoo! Answers:

How to map a keyword to a category?
I have a bunch of general categories, such as: Games, Modeling, Business, Finance, etc.

My question is, how can I take a keyword such as “Xbox 360″ and automatically map it to a category such as “Games”? This is an easy example, and I did figure out ways to do this, but if I take a harder example such as “Tyra Banks”, I am unable to map it to a category of mine such as “Modeling” or “Tv Shows”.

I have been thinking of this for a very long time, and I can’t come up with a concrete solution. I have also searched the web and found nothing that would provide this service.

Any ideas?

Basically, computers develop semantic understanding the same way we people do, only far less efficiently: Repetition of example. (In computer science, semantics are called ontology.)

The reason we are far more efficient is that we more easily create connections between things, and more quickly process those connections, than computers can manage.

For example, suppose I give you three categories: colloid, coagulant, polymer. Now, place “chocolate milk” into the proper category.

The problem for most people is, although they’re 100 percent aware of what chocolate milk is, they don’t know what colloids, coagulants or polymers are. (If you do, pretend you don’t and bear with me.)

Chocolate milk is a colloid; that is, a uniform distribution of solids in a liquid.

Colloid is a word most people have never heard, so it has no meaning (semantic) associated with it in most people’s minds.

However, now that you know what a colloid is, you can very quickly come up with two more: Pepsi and coffee. They, too, are uniform distributions of solids inside a liquid base.

You can make this association because even if you don’t drink them regularly, you’ve at least seen Pepsi and coffee on thousands of occasions. You are intimately aware of their properties and you can easily define how they are similar.

So because you know literally everything there is to know about Pepsi, coffee and chocolate milk, when I tell you that chocolate milk is a colloid, you automatically know that Pepsi and coffee are, too.

However, you also know that chocolate milk, coffee and Pepsi are not exactly the same thing. For example, you know that Pepsi is most often served cold, coffee is most often served hot and chocolate milk, when not served cold, is often called “cocoa.”

These are the kinds of relationships that are brutally difficult for computers to make. And it is difficult for many programmers, such as the questioner above, to get computers to handle this depth of semantic, in large part, due to our own inability to forget everything we know about everything.

Ontology Today

The most common form of semantic understanding in computer programming is frequency. That is, “how many times does Jesus occur in the New Testament?” If it’s a lot, then clearly the New Testament is about Jesus.

This is the basic methodology employed by search engines: If the word or phrase you seek appears often, and in the context of grammatically correct sentences, on a Web page, then the Web page is probably about the word or phrase you entered; if the URL, title or description of the page contains that word or phrase, then it’s even more likely the page applies to your search term.

(There’s more to weighting a search query than that, but let’s keep it basic for simplicity’s sake.)

I’m no math whiz, so I can’t really explain (or fully understand) the methodologies used by, say, the full-text or natural-language query searches that most modern databases can perform.

The interesting thing is that as time has gone by, Google and Yahoo! are more likely to return Web pages that contain what you meant to find, rather than what you specifically asked to get; today’s search engine results are a far cry from the results you’d get not even five years ago.

Of course, some of that is better, faster machines and more experienced programmers. But a lot of it has to do with the copious amounts of data now available to make the connections between what I asked for, the links I got and what I wound up clicking.

In other words, because there are so many Web searches for so many different terms, and Google / Yahoo! can analyze what people click on once they get their results, they can “teach” their systems how to make better semantic connections between search words and what people meant when they used them.

Forget Everything You Know, Then Ignore Everything You Learn

The problem for the programmer is that almost always, any new leap into ontology begs the question.

That is, you can’t get past the fact that you already understand the relationship between the words you are trying to link. You can’t forget them or even ignore them, no matter how hard you try, because pretty much the only thing your brain does is semantics.

Because you know the relationship, trying to establish how to create it becomes exceedingly difficult. As is the case with our drinks example, relationships often become complex and depend on variables that are in flux or are matters of understanding or circumstances — understanding and circumstances that often are as difficult to define as the relationship you’re trying to create.

The benefit of having voluminous amounts of data, such as Yahoo! and Google have at their disposal, is they can provide initially simplistic relationships, toss them into the lake, see which ones swim, and narrow the next set of results by promoting the ones that swam best.

With small amounts of data, such as this questioner has at his disposal, it’s nearly impossible to instruct a computer on how to make a relationship. The amount of data you’d need to use, in order for the computer to be able to come up with anything approaching reliable results, would be so overwhelming as to entirely defeat the purpose of writing the algorithm in the first place.

No related posts.

Tags: Google, REST

An Open Letter To A Programming Noob

Doug Vanderweide — Thu, 23 Aug 2007 20:54:34 +0000

Recently received in my e-mail:

Hi There

Found your email on your blog via the contact me which is linked to on your [Yahoo! Answers] profile.

I was curious as to what languages you program in as I am keen to get into programming and wanted any advise or recomendations for books.

I have done quite a bit of visual basic 6 which I know is not OOP.

Would be good to either do vb 2005 or c++ or java

Thanks

Shane

My response to this e-mail follows.

I was curious as to what languages you program in as I am keen to get into programming and wanted any advise or recomendations for books.

I program in several languages. Primarily I work in VB.NET but I also work in C#. In terms of scripting languages, I use PHP, JavaScript, Perl, ASP 3.0 and some ColdFusion. I know Transact-SQL and MySQL intimately and have some experience with PL/SQL. I know XHTML, XML and XSLT extensively.

In re: books for beginners, if you are a true noob — that is, you have little to no programming experience — I am a fan of the “For Dummies” series of books, which do an excellent job of walking you through the basics.

If you want to quickly learn how to use Microsoft Visual Studio to make programs in .NET, such as ASP.NET, VB.NET or C# — I am a big fan of the Step By Step series by Microsoft Press, such as Visual Basic .NET 2005 Step By Step. They focus on using Visual Studio to solve specific programming problems, such as working with databases, collecting user input via forms, etc.

You can see books I recommend at my Amazon.com aStore.

I have done quite a bit of visual basic 6 which I know is not OOP.

Actually, Visual Basic 6 is object-oriented. “Object-oriented” means many things, but to be really simple about it, it fundamentally means you create classes — aka objects — to accomplish programming goals.

While you can certainly write VB 6 programs as sequence-based code — like you write old-school ASP 3.0 or PHP programs — it is really designed to use objects. In fact, you could, in theory, write VB.NET programs as structured code, although it is harder to do since even the data types, such as strings, integers, etc., are designed to act like classes.

If you’d like more of an understanding of how classes / object-oriented programming work, check out this post on my blog:

http://www.dougv.com/2006/12/22/objects-classes-explained-in-very-simple-terms/

Would be good to either do vb 2005 or c++ or java

In re: which programming languages are “good” or “best,” there isn’t one. Each language has its strong points and its weak points. Which you choose should be a question of which you want to learn or find more comfortable, because there’s plenty of work to be had in all of them.

The only “required” language, as far as I am concerned, is SQL — no matter what programming language you learn, at some point you’re going to need a good understanding of SQL, since almost all applications come down to manipulating data somehow.

There are many variations of SQL — Transact-SQL (Microsoft), PL/SQL (Oracle), MySQL, PostGRE SQL, etc. — but if you understand ANSI SQL fairly well, then you can work out the quirks of each variation on the language easily.

I generally recommend to noobs that they at least give a crack at C++. I recommend that for several reasons:

It’s by far the most common programming language, which means finding peers to help you with it is very easy.
If you decide you want to get a formal postsecondary education in programming, almost every school out there will start you in C++; if you start with it before you start your formal education, you’ll have a head-start on most people.
Because ANSI C was one of the first programming languages and was embraced early by both Microsoft and Unix / Linux, it’s served as a model for many other programming languages — including C++, C#, Java, JavaScript, PERL, PHP and more. If you can understand C++ and its concepts, you’ll find it easier to grasp most other programming languages.

But again, what language you learn should be a matter of your personal choices and interests, not what other people think. You’re the person who will be doing the work, and your success will come from your happiness and confidence. If you don’t like a language or don’t feel competent using it, you won’t be successful.

Tags: data types, Linux, REST, Visual Studio, XSLT

A New Approach To Yahoo! Answers

Doug Vanderweide — Sat, 20 Jan 2007 05:23:57 +0000

Those of you who know me from Yahoo! Answers may be wondering why you don’t see quite as much of my answers around. As recently as last week, I was answering as many as 60 questions a day.

Part of that is now that the holidays have passed, I’m busier with paying projects. But a bigger reason is that I’ve rethought which questions I am going to answer. It occurred to me recently that there’s a huge difference between quantity and quality, and in addition, I’m taking a bit more offense than I should with poorly worded questions, stupid questions and people who reward wrong answers with “Best Answer.”

I know full well when I answer a question whether the questioner even understands what he is asking, nonetheless the answer I give. And I know, even better, the cliche that one should never teach pigs to sing, because it wastes your time and annoys the pig.

I also know better than to answer when it’s not needed or counterproductive, and it occurs to me that not following my own common sense makes me a fool.

So, from here on out, I’m using these basic guidelines for Yahoo! Answers:

If your question makes no sense whatsoever, I’m not going to try to figure out what you are talking about. And I’m not just referring to the surfeit of Indians trying to ask complex programming questions when they know all of five English words. I’m talking about questions that clearly indicate total confusion on a subject.

It’s one thing, for example, to call JavaScript “Java” or ask what “codes” you need to, say, get a certain recordset from a database. It’s quite another to ask, “Vb code for create database ADO with the help of coding help me plz.?“, which, not coincidentally, is the question that, as I was answering it, made me realize I was on a fool’s errand and needed to rethink which questions I should answer.

If a question already has a correct answer, I’ll thumbs-up the correct answer and move on. Nothing is more annoying, or potentially more confusing, than providing the same answer to a question that’s been answered correctly. More likely than not, the subtle differences between two right answers will only serve to confuse the questioner, and that’s contrary to the idea. So, if I see a good answer, I’ll mark it as such and move on to the next thing.

If a questioner clearly cannot fathom a correct answer, I’ll skip answering it. This may come off as arrogant, but I do an exceptional job of explaining complex things in simple terms. But I can only dumb things down so far, or hold your hand so long; you have to have the capacity and desire to learn. Nothing pisses me off more than giving a correct answer that I’m certain can be understood, only to have the retard who asked the question, because he doesn’t even understand what he asked, nonetheless any of the answers he got, vote as Best Answer something that is utter nonsense.

For example, there’s this dipshit, who gave Best Answer to someone who simply filibustered, even though I gave him a downloadable code and a full discourse, just as he asked. There’s also this idiot, who voted for the guy who simply plagiarized my earlier answer, and got the parts he added to my answer wrong. And just to prove this is no anomaly, there’s this moron, who gave Best Answer to a person who spewed anti-intellectual diarrhea all over the place.

If you don’t speak English, or use 1337 / StUdLyCaPs, or otherwise prove yourself a functional illiterate, I’ll move on. If you cannot, or do not, make yourself understood when you are seeking help, you cannot, or will not, understand my answers.

No more stupid questions (and yes, there are stupid questions). If your question could easily be answered with a simple search engine query, or by anyone who’s worked a computer for more than 30 seconds, I’ll move on. For example: Where can I find free message boards? How do I change the background picture on my screen? Where can I find tutorials for Dreamweaver?

No more non-programming questions. There are plenty of computer questions that aren’t related to programming but which are complicated. And there are hundreds of help desk people in the Computers & Internet section of Yahoo! Answers. They can handle questions about how to restore icons or what may be causing a given error. I’ll stick with what I know. There are also lots of people who can write basic HTML, JavaScript and SQL; I’ll start ignoring those questions, too.

Tags: REST

Stupid Web Site Tricks

Doug Vanderweide — Sun, 14 Jan 2007 03:09:40 +0000

Recently asked on Yahoo! Answers:

Is background music on websites to unprofessional?

[snip; was a URL]

that is my website I am working on for my uncle
I was thinking about putting some background music on it
(just a piano playin in background)

is this a good idea or should I not do it?

and what changes can I make to the site to make it look better? what can I add, what should I take off?

Which provides me with an excellent segue to point out all the annoying crap people on Yahoo! Answers insist on putting into their Web sites. I’ve listed the annoyances in order, from worst to simply just offensive.

If you do any of the following on your Web site, your site is awful. If you do more than one, you should immediately remove your site altogether, because it’s a crime.

Gizmos for the sake of having gizmos: If you want to add things to your Web site because you think your Web site is not interesting, maybe you should go do something or discover something interesting and put that on your site.

Because counters, games, flashing what-nots, chat, whatever, don’t make a Web site interesting and useful. Saying something useful and interesting makes a Web site useful and interesting.

A “splash” page, for any reason: I don’t care if your Web site is in 150 different languages, or you have 10 different versions depending on browser / Flash capability, or if you have the coolest logo ever designed. Splash pages are plain old stupid.

A splash page says one of the following:

You haven’t bothered making a home page that tells me anything about your site. Thus, your site isn’t worth reading. Goodbye!
You’re far more interested in showing me some crappy Flash animation or logo than you are in telling me why I should waste any more time on your site. Goodbye!
You’re too damn lazy to properly program your Web site to determine a Web browser’s capabilities. Thus, all the gizmos I’m likely to run across on your site will be poorly programmed and crash my browser. Goodbye!

Whatever the case, “splash page” translates as “stop sign.” If you use it, your site is crap.

Flashing or moving text: The purpose behind a Web site is to say something. It’s harder to read text if it flashes or moves; worse, it makes the text next to whatever else is flashing or moving hard to read, as well. If your Web site has flashing or moving text, you’re wasting both our time.

By design, the HTML DOM has elements that imply importance: H1 through H6. It also includes elements that set aside important parts of inline text: STRONG and EM. If you use those in the place of flashing or moving text, your site will index better with search engines.

Better yet, people won’t close their browser windows because your text is making them seasick.

Embedded music or video files without a warning: You are a serious ass if you embed a background music file on your site without warning people, and not just because doing it chews up bandwidth. True, these days, most people have broadband, but some don’t, and it’s wrong to attack such users just because they refuse to leap into the 21st Century or move to civilization, where cheap broadband is plentiful.

Most people expect Web pages to be silent. If you don’t tell them you are about to break the silence with your polyphonic rendition of “The Merry-Go-Round Broke Down,” it’s going to come as a shock to them. And no matter how popular your audio clip is, I assure you, many, many people who visit your site are going to hate it.

It’s even worse when you embed an MPG or other video file, because those are even larger, taking even longer to download, and almost always are a waste of time.

If your video is any good, put it on YouTube like a normal person does and embed the YouTube player on your site. It, at least, doesn’t start downloading until the person decides they want to view the video, and FLV tends to be a more efficienct video compression than MPG or even AVI, making the video download and play faster.

Not only does that save you bandwidth, it makes it a lot more friendly for visitors.

Whatever you do, warn people before they run into media clips. If I opened a book and a 20-inch TV fell out of it and onto my foot, I’d be pissed. I have the same reaction when I run into unannounced video or audio on a Web site.

And while I’m at it, if you feed a video file off your Web site, such as an MPG, which isn’t in a streaming media format, you’re a double-jackass. I don’t have to turn my TV on at 4:30 p.m. to watch the 6 o’clock news; I shouldn’t have to wait 5 minutes for the stupid video of you and your friends imitating the OK Go treadmill dance to start playing, either.

Meaningless Flash: Believe me, all your Flash animation is saying is, “I’ve learned enough Flash to waste your time and bandwidth, by animating some words and stock images into a 30-second loop that simply spits out meaningless slogans at best.” And I’m going to laugh at you if it takes 30 seconds for that animation to load.

Truth is, you don’t know enough about Flash and graphic design to use it well. I don’t know you from Adam and I can guarantee that’s the case. In the highly unlikely case I’m wrong, and you’ve put in the thousands of man-hours it takes to get good at both, you’ll still never find a circumstance where Flash was a better choice than vanilla HTML, JPGs and GIFs. I don’t know your client base from Eve, and I know that.

Here’s a tip: Don’t use Flash unless you are making a game or another interactive component. Here’s another tip: Even if you are making a game or another interactive component, don’t use Flash. Here’s a final tip: Flash sucks. Don’t use it, period.

One of the best bits of Web design advice I ever heard was this: Amazon.com spends bucketloads of money every year to research what makes a Web site customer-friendly. If you don’t see it on Amazon.com, don’t do it.

You’ll find plenty of AJAX, XHTML, dynamically displayed layers and the like on Amazon.com. And you may even see Flash in a banner or used to display book page samples. But you won’t see a single Flash animation used for navigation, and especially not to simply “pretty things up”, QED.

Linking to non-HTML documents without warning: This is especially a problem with PDF files but also with Word documents, Excel spreadsheets and the like. Nothing is more annoying than being very close to finding the information I want, only to have the next link I click launch my copy of Acrobat 7 — which takes about two minutes to load and pretty much prevents me from doing anything else with my Web browser.

Sure, I could disable PDF reading in my browser. But I want to be able to read PDF documents in it. What I don’t want is to have some moron link to what I expect to be a Web page, so that I stumble upon PDFs unexpectedly.

It takes you all of 5 keystrokes to add (PDF) inside the hyperlinked text to your damn PDF document. Let me have a choice between viewing it now and downloading it. Seize my computer up with unexpected content types and I’ll never visit your crappy Web site again.

Background images that aren’t simply small tiles: If you use an actual image as a background on a Web page, I have news for you: It’s 2007, and that crap is straight out of 1998. Don’t do it. It’s just distracting. Enough said.

Animated GIFs: Those, too, are totally ghetto geek. Unless the animation does a better job of explaining something than words would do, you’re just distracting me from your message. The same is true of …

Large, pointless images: Pictures may speak 1,000 words, but believe me, that scan of a black-velvet painting of a nearly naked warrior princess riding a winged unicorn is shouting, “You are a loser and an annoying ass.” Again, images should augment your site, not dictate it.

Using depricated HTML elements or attributes: If your site contains a single FONT, CENTER or U tag, or an “align” attribute in any text element, you’re a retard. Stop trying to learn HTML from Web pages written in 1996. Get a copy of XHTML for Dummies (With CD-ROM) and get up-to-date. It’s well worth the $20, and considering your woeful skill level if you’re still using those tags, probably your only hope for redemption.

Manipulating the DOM for the sake of manipulating the DOM: I don’t want to see a bunch of stars following my cursor across the screen, or have things I’m not expecting to change suddenly do just that for no apparent reason, or have to deal with your nonsensical attempts to block me from right-clicking on your page.

Again, at best you’re simply annoying me. At worse, you’re encouraging me to leave your site immediately — after I read the source code and steal everything you didn’t want me to steal.

Tags: REST

dougv.com « Doug Vanderweide » REST

Displaying Selected YouTube Data API Thumbnails On A Web Page Via ASP.NET Web Forms

Overview Of The YouTube Data API

Querying The YouTube Data API

Creating The Query String

Examining The XML Response

Traversing The XML Response Document

Creating Thumbs From Results

Related Posts

Getting QueryString Values From A Rewritten URL / ASP.NET Routing URL

Alternative: A URL That Does Not Begin With Key->Value Pairs

Keyless Array

The Right Rewriting / Routing Rules Make A Big Difference

Related Posts

MSDN Northeast Roadshow, Augusta, ME, May 11, 2010 Recap

Related Posts

Shortening URLs With The bit.ly API Via ASP.NET

Related Posts

Posting Status Updates (Tweets) To A Twitter Profile Via ASP.NET

Related Posts

Most Code Downloads Restored; Some Articles Deleted

Related Posts

Describing ‘Red’ To A Blind Man: The Dilemma Of Ontology

Ontology Today

Forget Everything You Know, Then Ignore Everything You Learn

Related Posts

An Open Letter To A Programming Noob

Related Posts

A New Approach To Yahoo! Answers

Related Posts

Stupid Web Site Tricks

Related Posts