dougv.com « Doug Vanderweide » Visual Studio

Disable Windows Antivirus When Installing aspell English Dictionary

Doug Vanderweide — Wed, 29 Feb 2012 19:49:35 +0000

A lesson I learned the hard way today, while installing aspell support for Notepad++:

If you’re installing Kevin Atkison’s English dictionary for aspell, you need to disable your antivirus program (at least, if you’re using Avast, as I am).

If you don’t, the dictionary installer can’t write its unpacked files to disk and will fail silently. As in, it just plain closes, and Notepad++ will report something along the lines of “Aspell and/or dictionaries are missing.”

FYI.

Also, if you haven’t heard of Notepad++, you should check it out. It’s an open-source, GPL-licensed Win32 text editor. (It runs perfectly fine in Win64).

Highly extensible via plugins, translated to all kinds of languages, exceptionally powerful, with support for syntax highlighting in just about every programming language under the Sun and syntax checking for a fair number of them, too.

It’s pretty much the only tool I use any more for Web coding, even when writing ASP.NET Web Forms. (I still use Visual Studio for some Windows coding. But Notepad++ has completely replaced Dreamweaver.)

All links in this post on delicious: http://delicious.com/dougvdotcom/disable-windows-antivirus-when-installing-aspell-english-dictionary

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: developer tools, Microsoft, MSDN, notepad++, open source, Visual Studio

New England GiveCamp 2011: What A Weekend!

Doug Vanderweide — Tue, 03 May 2011 22:40:04 +0000

Last weekend was New England GiveCamp 2011, in which 100+ developers, designers and other volunteers gathered to donate time and skills to some 30 charities who needed IT help.

This year, I was project lead for Alex’s Team Foundation, based in Andover, Mass. Our team was Saurabh Moondhra and William Wade, both experienced ASP.NET developers.

Alex’s Team Foundation, named after 16-year-old Alex Miliotis, who passed away from leukemia in 2002, raises money to support nurses and other oncology professionals, and supports youth sports. The foundation is largely the labors of Patti Rae Miliotis, Alex’s mother, and a handful of reliable volunteers. Like every small nonprofit, Alex’s Team doesn’t have a lot of money.

From the right to left: William Wade, Doug Vanderweide, Saurabh Moondhra and Patti Rae Miliotis of Alex's Team Foundation. The lady with her feet up is Deanna Lohnes, who worked on another project; the woman in green, whose name I do not know, was her charity's contact person.

Like every other leader of a small nonprofit, Patti is pulled in a lot of different directions and has all she can do to keep track of the people with whom she comes in contact, nonetheless all the donations she gets. Patti also hosts a few events every year. She basically needs a way to keep track of who attends those events or otherwise supports her organization, and to mail merge thank-you notes.

So that was the project I led this weekend: Converting a bunch of data stored in (of course!) Excel spreadsheets into a more relational database, with the ability to export that data in order to mail merge thank-you and fundraising letters.

CiviCRM: Too Much, Too Late

At first, I thought we could use CiviCRM, which is a Joomla / Drupal extension to manage membership, events, capital campaigns, email lists and the like.

The primary benefit in it, to my thinking, was that it does most of what Patti needed done; so, if she could use it, most of the work would already be done. That would allow us not only to import her spreadsheets, but also pay some attention to re-skinning the foundation’s current Web site (which is sorely needed).

CiviCRM’s biggest drawback is a huge learning curve. It is not easy to understand out of the box, especially if someone doesn’t have prior experience with customer relation management software. That was Patti’s problem: It was too daunting, much like the system she had tried previously.

So our task played directly to our strengths: Make an easy-to-use contact database on the Web, which could also track donations and event registrations.

Friday: Three Ways To Skin A Cat

Patti asked that we use Access to make her database, since she has some experience with it. Unfortunately, nobody on our team knew much about Access, and at least two of us have had negative experiences with it.

At last year’s GiveCamp, William wound up having to become an on-the-spot Access developer, and it left something of a sour taste. I’ve never had much success building standalone Access databases, largely because I find its visual query and form designers extremely limiting. Saurabh said he had little to no experience with Access.

The one thing we all knew was ASP.NET Web Forms. Well, to be specific, we knew three different versions of ASP.NET Web Forms. Saurabh programs in C#. William and I prefer VB.NET. William likes using Linq; I prefer old-school stored procedures; Saurabh likes inline SQL statements.

The good thing in that is, an ASP.NET Web application doesn’t need to run under just one language, and so long as the connections and queries are good, you can mix and match database layers to your hearts’ content.

So we settled in to design a database schema that could record contacts, donations and events. That consumed most of Friday night’s efforts. Here’s how it looked on the whiteboard. (Saurabh took this with his cell phone camera. Click it for full-size, which is easier to read.)

Saturday: Tackling The Obstacles

Saturday started with a lot of little hiccups.

DiscountASP.NET very kindly donated the Web hosting for our application. However, they require a domain name in order to host a site, and wouldn’t donate that. Because we weren’t redesigning the Alex’s Team site, which needed to remain on its current server, we couldn’t use the one domain name Patti had. So I popped on over to GoDaddy and bought a special domain for the occasion.

With a domain in hand, we could go ahead and create our application. Except that DiscountASP.NET, which would also donate a SQL Server database, has a separate ordering process for add-on services, which meant we would be delayed for several hours while we waited for the database to be set up.

Since our entire application was basically just a GUI to a relational database, we really couldn’t get much done without a database. So I tried to use one of my free GoDaddy Web hosting credits to set up service sufficient to get us started.

Unfortunately, I couldn’t use the newly registered domain to access any free service, because I guess the registration was too new; also, all the other domains I have registered through GoDaddy point to something, so I couldn’t use one of those.

Thankfully, GoDaddy will sell Web hosting for $8 for one month without need for a contract, so I just went ahead with that; and within 30 minutes, we were able to build our database and start making forms.

For the record, DiscountASP.NET came through for us completely by early Saturday afternoon. It was only my panic, lack of timely preparation / organization and impatience that made me use GoDaddy. This application will soon be moved to DiscountASP.NET, where it will permanently reside. I’ve used DiscountASP.NET for Web hosting in the past and in terms of features and reliability, they simply cannot be outdone.

I didn’t pre-install Visual Studio on my crappy laptop; that took two hours out of Saturday morning. A new laptop will definitely be in the offing for next year.
While waiting for that install to finish, I went on a wild goose chase for a convenience store in Cambridge. Suffice it to say, the one nearest to NERD is a 7-Eleven about a half-mile away; but I wound up hanging around for about 45 minutes outside the Coop, waiting for it to open, because I was mistakenly led to believe it sold tobacco. (I fell off the no-smoking wagon for the weekend; I knew there would be some stress, and nicotine definitely keeps me calm.) So what should have been a 20-minute break turned in to an hour and a half.

I was gone so long in search of smokes, Saurabh accused me of going to get stoned. It was a reasonably accurate portrayal.

Somewhere around 1 pm, I mistakenly thought we would have to work in ASP.NET 2.0 in order to resolve some namespace and other issues, and I communicated as much to my team. This led them to delete what they had made to that point. Within 5 minutes, William had corrected my error. Saurabh was nonplussed.
After dinner, we were ready to start integrating our files. Non unexpectedly, we ran into a number of small issues. It took a little while to get William’s files working on my laptop, but try as we might, we just couldn’t get Saurabh’s C#-based solution to work. So he wound up converting them to VB.NET. I went back to the hotel to finish my part of the solution.

On Saturday night, I gave a quick overview on WordPress for the non-profits that I fear was a real snoozer. (Memo to self: Never host a seminar after dinner.) During that, I won my choice of a number of software prizes; but what was left available in the first-come, first-served prize pool didn’t really thrill me.

William had his eye on a copy of DevExpress DXPerience Enterprise, a bunch of .NET controls, worth about $1,300 on the retail market. I seldom program in Windows and he does all the time, so I transferred my winnings to him.

A Word About The Royal Sonesta

While many GiveCampers — William and Saurabh among them — spent the night at NERD, I stayed at a hotel, because I’m too old and fussy to be sleeping on hard floors. Also, I’m in Cambridge, which is quite a treat for me, and I wanted a chance to spend at least a little time in the city each night, even if it was just walking a half-mile to the hotel and having a drink or two in the lounge. So I opted to stay at the Royal Sonesta, which had the best rates.

View New England GiveCamp 2011 in a larger map

This simple plot was foiled, however, by the Royal Sonesta’s unfathomable renting out of the first-floor lounge on both Friday and Saturday night. On Friday, I was able to get a single beer, but it felt very strange crashing a private event and I wound up calling it a night early. On Saturday, they just turned me away, period, because a wedding reception was being held there.

Also, while the Sonesta loudly advertised its local shuttle service, they require you to register for it; and nobody saw fit to remind me of it at the concierge desk, when I asked for a shuttle schedule. As a result, I stood outside for a half-hour on Friday night, waiting for a shuttle that never showed up.

Overall, the Sonesta’s staff was courteous and friendly; especially the front desk, porters and valets. But the concierges were inexplicably surly, brusque, unapologetic and unhelpful.

So while the price was great ($144 per night, amazingly good for Cambridge), the hotel was clean and the room / amenities nice, I cannot recommend the place. I mean, what kind of hotel closes its lounge to guests? And has concierge service that basically looks to do as little as possible, and that with a frown on its face?

Sunday: It All Comes Together, Like Magic

The great benefit of having competent, skilled and motivated team members is that their sense of urgency and their ability to adapt and overcome adversity are both fine-tuned. That was certainly the case with William and Saurabh; they were pretty much done by Sunday morning, and all we had to do was take one more crack at getting all three parts to play nicely with one another.

I let that task fall to William, and he did an extraordinary job getting everything to work; certainly, a much better job than I would have done. Meanwhile, Saurabh settled in to help Patti make some upgrades to her Web site, notably in getting her Paypal donation button working again, adding in some alternative donation options and adding Google Analytics to her site.

Saurabh also won an instant drawing on Sunday and scored a copy of Age of Empires III for PC. I had my heart set on winning a WiFi-enabled Kindle, which was being given away at the end of GiveCamp; but that didn’t happen.

Not to say we didn’t get some great swag:

A full-boat copy of Microsoft Office 2010 Professional. Awesome!
A thumb drive. You can never have too many of those.
A set of jewelers’ screwdrivers. Again, you can never have too many of them.
A screw-top sippy cup with durable straw. Which is exactly what my spill-prone self needs to have on his work desk.
A miniature Nerf football. Awesome stress reliever.
A pen and pad of paper. Again, never can have enough of either.
A puzzle book. Not that I had time during the weekend to mess with puzzles.
A GiveCamp T-shirt. I like T-shirts as mementos.

During the weekend, Jim O’Neil dropped scores of additional treats on a giveaway table, many of which were O’Reilly books. I managed to get a spare puzzle book, several notepads, a PL/SQL quick pocket reference, Access 2010: the missing manual and Visual Basic 2010 Step By Step. There were a number of other books available but I was too slow to score them. However, I understand I am allowed a free ebook from O’Reilly, as well.

The bottom line is that we got our project done, it works, Patti seems fairly pleased with it and we had a great time this weekend. It’s definitely renewed my commitment; I’ll be a GiveCamper until I can’t do it any more.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/new-england-givecamp-2011-what-a-weekend

Tags: crowdsourcing, ethics, GiveCamp, GoDaddy, Google, graphic design, Jim O'Neil, marketing, MSDN, Visual Studio

Automatically Hash Tagging Text With ASP.NET Web Forms (VB.NET)

Doug Vanderweide — Mon, 25 Apr 2011 01:14:41 +0000

I had previously blogged a solution in PHP to automatically hash tag an input string with various terms stored in a database. Here’s an ASP.NET Web Forms version of the same solution (this one should work for ASP.NET 2, 3.5 and 4).

To review, a hash tag is a bit of text, led with a hash mark (#), that serves to indicate to some Web sites / services — notably, Twitter — that the word thus marked should be treated as a tag. This code will take some piece of input text, search it for terms we generally want to tag, and mark the instances in that input string with hash tags.

As in the previous solution, we’ll define a “word” for the purposes of this demo to be any alphanumeric character sequence that is followed by a space or a newline. Also, this demo will only tag text; it won’t automatically add new terms to the database. That will be the subject of an upcoming post.

I’m going to use three ArrayLists as the workhorses for this solution. One will hold the terms from the database; the second will contain all the distinct words in the input string; and the third, the words from the input string that are hashtag terms.

The HTML / ASP.NET Controls

For the purposes of this demo, we’ll just have a form with a Label (to show results or error messages), TextBox (to provide the input text), a RequiredFieldValidator and a Button. I’ll also output in a DetailsView, bound to a SqlDataSource, all the terms stored in the database at the moment.

Automatically Hashtagging An Input String







Terms in the database

	
		<%#Eval("term_text")%>

The GetAllTerms Function

First up, a function that retrieves from the database all the hashtag terms and returns them as an array.

Function GetAllTerms() As ArrayList
	'retrieves all terms from the database
	'returns empty ArrayList on error,
	'populated ArrayList on success

	Dim arrOut As New ArrayList()

	Dim objConn As New SqlConnection(ConfigurationManager.ConnectionStrings("your connections string").ConnectionString)
	Dim objCmd As New SqlCommand("your stored procedure", objConn)
	objCmd.CommandType = CommandType.StoredProcedure

	Dim objReader As SqlDataReader
	objConn.Open()
	objReader = objCmd.ExecuteReader()
	While objReader.Read()
		arrOut.Add(objReader(0))
	End While
	objConn.Close()
	objCmd.Dispose()
	objConn.Dispose()

	Return arrOut
End Function

The ExtractTerms Function

Now we need to get all the potentially taggable words in our input string.

Function ExtractTerms(ByVal strInput As String) As ArrayList
	'extracts all words from textbox
	'returns them as ArrayList, empty ArrayList on error
	'words are any alphanumeric sequence before a space or newline

	Dim arrOut As New ArrayList()

	Dim reWords As New Regex("\w+(\s|$)", RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant)
	Dim reMatches As MatchCollection = reWords.Matches(tbInput.Text)

	For Each reMatch As Match In reMatches
		arrOut.Add(reMatch.Value.Trim)
	Next

	Return arrOut
End Function

The CompareLists Function

Now that we have ArrayLists with all terms and all words, we can compare the two, and create an ArrayList that contains the words we intend to tag.

Note that we take care to cast the terms and words to lower-case, and return the input text version of any terms found. That’s because we want to preserve case in the input string. That’s also why I can’t use the ArrayList.Contains method; it’s case-sensitive when comparing strings. (Actually, that can be overridden or worked around; but it’s involved and somewhat complicated, so it’s also a subject for some other column).

Function CompareLists(ByVal arrTerms As ArrayList, ByVal arrWords As ArrayList) As ArrayList
	'compares term list against word list
	'returns ArrayList with all words found in terms
	'maintains case

	Dim arrOut As New ArrayList()

	For Each strWord As String In arrWords
		For Each strTerm As String In arrTerms
			If strTerm.ToLower = strWord.ToLower Then
				arrOut.Add(strWord)
				Exit For
			End If
		Next
	Next

	Return arrOut
End Function

The AutoTagSubject Function

Finally, we need a function that will take the words we want autotagged, and apply the autotagging to the input string.

Note that before we proceed with tagging, we remove all current hash marks from the input string. That’s to avoid double-hashing words that may have been tagged in the input text.

Function AutoTagSubject(ByVal strInput As String, ByVal arrTerms As ArrayList) As String
	'applies arrTerms as hashtags to strInput
	'removes hashtags first to avoid double-tagging

	Dim strOut As String = strInput
	strOut = strOut.Replace("#", "")

	For Each strTerm As String In arrTerms
		strOut = strOut.Replace(strTerm, "#" & strTerm)
	Next

	Return strOut
End Function

The btnSubmit_click Subroutine

We now need a simple subroutine to invoke our functions and autotag the input text.

Sub btnSubmit_click(ByVal Sender As Object, ByVal E As EventArgs) Handles btnSubmit.Click
	'get terms from database
	Dim arrTerms As New ArrayList()
	arrTerms = GetAllTerms()

	'get unique words from input text
	Dim arrWords As New ArrayList()
	arrWords = ExtractTerms(tbInput.Text)

	If arrTerms.Count < 1 Then
		lblResult.Text = "There are no terms in the database, or there was an error retrieving the terms."
		lblResult.CssClass = "warning"
	ElseIf arrWords.Count < 1 Then
		lblResult.Text = "There are no words in the string to be tagged."
		lblResult.CssClass = "warning"
	Else
		'get matches between terms and input words
		Dim arrHashes As New ArrayList()
		arrHashes = CompareLists(arrTerms, arrWords)

		If arrHashes.Count < 1 Then
			lblResult.Text = "There were no matches between the input text and the terms in the database."
			lblResult.CssClass = ""
		Else
			'display found terms
			Dim sbMsg As New StringBuilder("The following terms were found: ")
			For Each strTerm As String In arrHashes
				sbMsg.Append(strTerm)
				sbMsg.Append(", ")
			Next
			sbMsg.Remove(sbMsg.Length - 2, 2)
			lblResult.Text = sbMsg.ToString()
			lblResult.CssClass = ""

			'autotag input string
			tbInput.Text = AutoTagSubject(tbInput.Text, arrHashes)
		End If
	End If

End Sub

And that’s all there is to it. You can see a working demo at http://www.dougv.net/demos/auto_hashtag/

You can also download the demo code. I distribute code under the GNU GPL.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/automatically-hash-tagging-text-with-asp-net-web-forms-vb-net

Tags: arrays, hashtags, Microsoft, regular expression, Visual Studio

Creating An ASP.NET RSS Feed, Using Data From SQL Server And HTTP WebHandler

Doug Vanderweide — Sat, 11 Dec 2010 06:14:35 +0000

There are a couple of ways to create an RSS feed from a SQL database store. Over at 4GuysFromRolla.com, there’s a post explaining how to create an RSS feed using a regular old ASP.NET Web Form.

Another option would be to write a script that creates an actual XML file on some periodic basis (probably just before the recommended “time to live” setting of the feed). The benefit of that is, one taxes the database server a little every now and then, and a “real” XML file does the work.

But as a rule, for ASP.NET applications, Microsoft recommends using HTTP handlers or modules whenever one wants to present data other than HTML.

A handler is a special ASP.NET Web page; a module is a plug-in one can install in Internet Information Server. If you’ve got a lot of different, special-case Web processing, or one need that is near-constant — such as processing images stored in a database every time a specific page is called — then you’ll want to consider a module. For occasional or lightweight processing, such as serving up a low-use RSS stream, a handler will do fine.

So that’s what we’ll use here. Let’s begin by creating an ASP.NET HTTP handler, which is written in the same way one would write the code behind for an ASP.NET page, but uses the file extension .ashx.

Creating An ASP.NET HTTP Handler

Fortunately, handlers are very easy to create, especially if you’re using Visual Studio / Visual Web Developer Express as your IDE. You can select it (“Generic Handler”) right from the Add New Item menu:

<@ WebHandler Language="VB" Class="Handler"; >

Imports System
Imports System.Web

Public Class Handler : Implements IHttpHandler

    Public Sub ProcessRequest(ByVal context As HttpContext) Implements IHttpHandler.ProcessRequest
        context.Response.ContentType = "text/plain"
        context.Response.Write("Hello World")
    End Sub

    Public ReadOnly Property IsReusable() As Boolean Implements IHttpHandler.IsReusable
        Get
            Return False
        End Get
    End Property

End Class

What this really does is create a special class for handling our request. And since we may well have several different kinds of handlers in our Web application, we ought to change the name of the class to be more meaningful — that is, to better reflect what the class is actually doing.

In the case of our handler, we’re creating an RSS feed. So, let’s rename the handler to RSSFeed.ashx. If we do that at the time we create the handler, Visual Studio will make the necessary changes for us. However, if we’re making this file by hand, we need to declare the class name in our WebHander directive declaration:

<%@ WebHandler Language="VB" Class="RSSFeed" >

We also want to change the class declaration:

Public Class RSSFeed : Implements IHttpHandler

Add Required Namespaces

With our HTTP handler created, we can move on to programming the specific solution. Let’s add the namespaces we need. I’m going to use an XMLTextWriter to create the feed, and SQL Server to provide the data. Therefore, I need the System.Text, System.Xml, System.Data and System.Data.SqlClient namespaces:

<@ WebHandler Language="VB" Class="RSSFeed" >

Imports System
Imports System.Web
Imports System.Xml
Imports System.Text
Imports System.Data
Imports System.Data.SqlClient

Public Class RSSFeed : Implements IHttpHandler

Create Function To Retrieve Records From Database

To help abstract this solution, I’m going to break out the process of getting the records from the database into a function. This function will return a DataSet, which I will consume in the ProcessRequest subroutine.

Private Function GetArticles() As DataSet
	Dim conn As New SqlConnection(ConfigurationManager.ConnectionStrings("my_connection_string").ConnectionString)
	Dim cmd As New SqlCommand("my_stored_procedure", conn)
	cmd.CommandType = CommandType.StoredProcedure

	Dim ds As New DataSet

	conn.Open()
	Dim da As New SqlDataAdapter(cmd)
	da.Fill(ds)
	conn.Close()
	cmd.Dispose()
	conn.Dispose()

	Return ds
End Function

Note that I am not checking for errors here. That’s because I don’t know what might be an acceptable error-catching scheme for you, and I don’t want to complicate this post with error-trapping methodologies you cannot use. But you should definitely check for errors.

If anything goes wrong, the DataSet as written won’t have any DataTable objects; you could always test for that, but I agree with John Sonmez at ElegantCode.com that throwing a null instead of an exception is a form of laziness.

If I were writing this handler for production, I would add a Try-Catch block. How you trap DB errors is up to you, but again, you should definitely trap them.

Prepare The Handler To Cache Results And Respond With The Proper Type

I need to instruct the handler as to what content type it’s creating. And I also want to cache these results, so that I don’t call upon the database every time someone wants to access the feed.

I’ll set the handler to produce XML, with UTF-8 encoding, and to cache results for one hour.

Public Sub ProcessRequest(ByVal context As HttpContext) Implements IHttpHandler.ProcessRequest
	'send document as response
	context.Response.ContentType = "text/xml"
	context.Response.ContentEncoding = System.Text.Encoding.UTF8
	context.Response.Cache.SetExpires(DateTime.Now.AddSeconds(3600))
	context.Response.Cache.SetCacheability(HttpCacheability.Public)

Sure, I could have used AddHours instead of AddSeconds here. That would have been better, but I’m a bit too lazy to change it now. I program a lot in PHP / JavaScript, too, so when working with time, I tend to go the Unix timestamp route by default, which generally means working in seconds.

(Aside on caching DB results: If I wanted to get all fancy, I could set the handler’s cache expiration to whenever there are changes to the underlying SQL Server data, via the SqlCacheDependency class. But that requires extra code and confuses the process to some extent, so I’ve simply fixed the cache time to one hour, which is the same as my feed’s TTL. End of aside.)

Use XmlTextWriter To Create The RSS Feed

With our records on hand, we can go ahead and create the feed. I do that with an XmlTextWriter that is set to become the output stream for the handler. (That is, I tell the handler, “Take a look at this here XmlTextWriter I’m making. You and it are the effectively same thing. Whatever it does, that’s what you’re doing.”)

I set the XmlTextWriter to encode its XML file in UTF-8, and then I create the opening data:

'create RSS xml document
Dim xml As New XmlTextWriter(context.Response.OutputStream, Encoding.UTF8)
xml.Formatting = Formatting.Indented

xml.WriteStartDocument()
xml.WriteStartElement("rss")
xml.WriteAttributeString("version", "2.0")

'create feed header section
xml.WriteStartElement("channel")
xml.WriteElementString("title", "ASP.NET RSS Feed - Web Handler Demo")
xml.WriteElementString("link", "http://www.dougv.net")
xml.WriteElementString("description", "A demonstration of using an ASP.NET Web Handler to create an RSS feed of SQL Server data")
xml.WriteElementString("language", "en-us")
xml.WriteElementString("pubDate", DateTime.UtcNow.ToString("r"))
xml.WriteElementString("lastBuildDate", DateTime.UtcNow.ToString("r"))
xml.WriteElementString("managingEditor", "dougvanderweide@gmail.com")
xml.WriteElementString("webMaster", "dougvanderweide@gmail.com")
xml.WriteElementString("ttl", "60")

Note that, at Line 34, I use UTC time and output it in RFC1123 format. That’s the RSS standard.

Because I want to ensure as many RSS readers as possible access this file as little as necessary, I ensure that the last build date is easily understood, and provide my time-to-live value at Line 37. That way, a well-made RSS reader should locally cache the RSS feed until the last build date / TTL values indicate it’s time to get a fresh copy.

Iterate Through The DataSet’s Records And Add Them As Items

With that out of the way, we can now focus on the ProcessRequest subroutine. First, we create a local DataSet that calls the GetArticles() function, previously described. Once that’s loaded, we go ahead and iterate the results, adding each as an of the feed:

'get top stories
Dim ds As DataSet = GetArticles()

'add stories to feed
Dim row As DataRow
For Each row In ds.Tables(0).Rows
	xml.WriteStartElement("item")
	xml.WriteElementString("title", row("article_title"))
	xml.WriteElementString("link", row("article_link"))

	'output story as cdata
	xml.WriteStartElement("description")
	xml.WriteCData(row("article_text"))
	xml.WriteEndElement()

	xml.WriteElementString("pubDate", CType(row("article_date"), DateTime).ToString("r"))
	xml.WriteEndElement()
Next

Some of the data I intend to output contains HTML entities (i.e., HTML markup). When you create an XML document that contains entities, you must output that data as CDATA. So where before, I was using the WriteElementString method to output quick-and-dirty child tags, Lines 50-52 use the necessarily much more verbose methods WriteStartElement, WriteCdata and WriteEndElement.

Lastly, note that at Line 54, I intentionally cast the database’s date value to DateTime, so that I can be absolutely certain that when I use ToString to format it, I get the result I want.

Close Tags, Flush The Buffer And Close The XmlTextWriter

Now we can go ahead and close all open XML tags, flush the XmlTextWriter’s buffer (that is, go ahead and output the document), and close the XmlTextWriter. We can also declare the end of the ProcessRequest subroutine:

	'close channel
	xml.WriteEndElement()
	'close rss
	xml.WriteEndElement()
	'close document
	xml.WriteEndDocument()
	xml.Flush()
	xml.Close()

End Sub

I use both the Flush and Close methods on the XmlTextWriter to ensure that the handler is entirely clear that it can go ahead and send its response.

This is almost certainly overkill; I could probably get away with just calling Close. However, I don’t like chancing that the buffer will output completely to the handler’s response stream without an explicit instruction to do so, and that’s the primary purpose of Flush. So that’s why I call both.

Demo, Download And Links

And just like that, we have an RSS feed. You can see a working demo at http://www.dougv.net/demos/rss_web_handler/

I distribute this code under the GNU GPL version 3. Download the ASHX file: Creating An ASP.NET RSS Feed, Using Data From SQL Server And HTTP WebHandler Sample Code

All links in this post on delicious: http://www.delicious.com/dougvdotcom/creating-an-asp-net-rss-feed-using-data-from-sql-server-and-http-webhandler

Tags: Google Reader, IIS, metadata, Microsoft, MSDN, RSS, Visual Studio, web server, Web Services

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

FAQ Released For Microsoft ASP.NET CryptographicException Attack

Doug Vanderweide — Tue, 21 Sep 2010 05:19:01 +0000

Scott Guthrie, Microsoft’s corporate vice president for the .NET platform, posted on his blog late Monday a FAQ about the ASP.NET CryptographicException vulnerability.

Highlights:

All versions of ASP.NET are affected. That includes WebForms and MVC versions 1 and 2.
Sharepoint is affected, too. A workaround on how to employ a new generic error document for Sharepoint is detailed at that team’s blog.
Everyone should employ the recommended workarounds.
You have to route all HTTP errors to the workaround’s generic error page. Otherwise, the hack still works.
A patch will be released as a Windows Update hotfix, but no release date has been set yet.
Check your logs for CryptographicException errors. If you see them, it’s possible you are being probed.

I take this very seriously. There’s a tool and video tutorial out there detailing how to run this exploit, so every script kiddie in the world is looking for sites to exploit, I am sure.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/faq-released-for-microsoft-asp-net-cryptographicexception-attack

Tags: hacking, IIS, Microsoft, MSDN, Scott Guthrie, Visual Studio, web server, Web Services, Windows Server

Major Security Hole In ASP.NET Requires Error Redirect Workaround

Doug Vanderweide — Sat, 18 Sep 2010 14:44:26 +0000

A major security flaw in ASP.NET was announced on Friday — one that affects all versions and can allow an attacker to see ViewState and web.config data in clear text.

As such, everyone who has made an ASP.NET Web site should take this threat very seriously.

Microsoft is putting together a patch. Until then, they suggest a workaround of turning on customErrors, and having it point to a single error file.

For ASP.NET versions 1.x, 2.0 and 3.5, create a single HTML-based error page, upload it to the root directory of your Web site, then add or change the customErrors section in your web.config file with the following:

Where, of course, error.html is the name of the error page you made.

If your site uses ASP.NET 3.5 SP1 or ASP.NET 4.0, use the custom ASPX error page located on Scott Guthrie’s blog (VB and C# versions), and change the customErrors section of your web.config file thus:

Where, of course, error.aspx is the name of the error page you created.

To make things easier, I have zipped up copies of the three error documents — error.html, and the VB.NET / C# versions of the ASP.NET error files — for download. I distribute all code under the GNU GPL.

I’m taking this threat very seriously and have patched all my ASP.NET sites as advised.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/major-security-hole-in-asp-net-requires-error-redirect-workaround

Tags: hacking, IIS, Microsoft, MSDN, rewrite, Scott Guthrie, Visual Studio, web server, Windows Server

Designers And Developers: Donate Your Time, Talent At New England GiveCamp, June 11-13, 2010

Doug Vanderweide — Fri, 14 May 2010 00:49:33 +0000

One of the things I found out about at Tuesday’s MSDN Northeast Roadshow stop in Augusta is the first New England GiveCamp, June 11-13 at Microsoft’s Northeast Research and Development center in Cambridge, MA.

I’m attending, and I’d urge you to do so.

A GiveCamp is basically a gathering of developers, DBAs, project managers, designers and other IT folks in a given place, to donate their time and skills to charitable projects.

In the case of the New England GiveCamp, typical projects include upgrading Access databases, or converting Excel spreadsheets to Access; integrating open-source tools, such as Joomla, Drupal and Django, into existing Web sites; adding various gizmos to and tuning up existing Web sites; and several requests to spruce up the look of various types of collateral.

I believe the biggest mistake you could make in deciding whether to participate is thinking that you don’t have the kind of skills needed. From what’s been said at the GiveCamp’s Web site, there’s going to be plenty to do, whether you’re Linus Torvalds or Linus Van Pelt.

I think this goes doubly for graphic designers. Trust me, if you are an artistic person, no matter how little you think of your work, your worst effort is 10 times better than the best design ever produced by a programmer. I am speaking from extensive personal experience here. We’re the people who gave the Internet Comic Sans, animated GIFs and the tag, remember. Please, save us from ourselves.

As the Northeast GiveCamp put it, “If you have the passion, we’ll find a place for you.”

In addition to the technical work on site, there are a myriad other volunteer opportunities both before and during the event, including registration, sponsor solicitation, organizing the development teams and matching them to non-profit organizations, handling logistics for food and snacks, and others we’ll discover along this journey!

And, of course, businesses can help, too. The GiveCamp says they’re not so much interested in money as they are services: Donation of meals and promotional items (mugs / T-shirts) are specifically mentioned.

Microsoft will make sure you get fed during the event. They will also provide crash space in NERD, provided you bring your own sleeping bag / air mattress; and they have showers on site (BYO toiletries). If you don’t like that idea, NERD is very near the Kendall / MIT MBTA station.

The only specific demands the GiveCamp has are, if you’re providing technical help to a project, commit to doing the entire weekend; and bring your own laptop (read: any needed software, such as Visual Studio / Dreamweaver, too; how you’ll tackle the project to which you have been assigned will be determined by a conference call before the event).

If you can’t commit to the whole weekend, the GiveCamp could still use your help, and will work within your schedule.

I really do hope you consider participating. Register at the GiveCamp’s EventBrite page.

Look at it as giving back, or paying forward; either way, you’ll help people who need the help, and meet people who can help you, in turn.

All links in this post on delicious: http://delicious.com/dougvdotcom/designers-and-developers-donate-your-time-talent-at-new-england-give-camp-june-11-13-2010

Related Posts

Visual Studio 2010 / .NET 4 Events For Maine-Based Developers (33.8)

MSDN Northeast Roadshow, Augusta, ME, May 11, 2010 Recap (17.1)

Live From The Microsoft Launch 2010 Event In Boston (16.1)

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: crowdsourcing, MSDN, Visual Studio

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

Related Posts

MSDN Northeast Roadshow: Sept. 24 in Augusta, ME (67.1)

MSDN Roadshow In Augusta, March 19: Well Worth The Time (50.1)

Visual Studio 2010 / .NET 4 Events For Maine-Based Developers (28.7)

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: 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

The Visual Studio Launch 2010 Boston Event, Reconsidered

Doug Vanderweide — Sat, 01 May 2010 07:33:39 +0000

Now that I’m a day or so removed from the Visual Studio “Launch 2010″ event in Boston, have plenty of sleep under my belt, and the benefit of hindsight, I’d like to recap my impressions.

I still consider Launch 2010 a significant disappointment, especially compared to the “Heroes Happen Here” launch of Visual Studio 2008 / SQL Server 2008 / Windows Server 2008 that was held in Manchester, NH, two years ago. But I should explain why, and maybe at least put in context, if not rephrase, my criticisms of Thursday.

Attendance: I need to clarify my attendance estimates from Thursday.

I’m guessing there were about 1,000 people in attendance at Launch 2010, which had three tracks: two all-day tracks for developers and IT professionals, and a half-day track for managers / decision makers. Of the total number of attendees, well over half — at least 500 — were in the developer track. I don’t have an exact count because I don’t know who to ask for one, and I doubt there is an accurate count in any event, because Microsoft was allowing walk-ins throughout the event.

However many people were there, it was too many, at least for the developer track. They ran out of seats by 9:30 AM and it only got worse until 3:30 PM, after the ASP.NET session, after which a large number of people left. I did pop in on the IT pro track, after I couldn’t regain my seat following lunch; there were a few empty seats available there.

Allowing such a significant overflow is a huge kick in the balls. I took the time to register ahead of time. I took great pains to ensure I would arrive on time. If you’re letting people filter in six hours after they were supposed to show up, you’re not being fair to me — especially if I can’t fully enjoy the event.

To me, this is straightforward: If you want people to come and go at their pleasure, don’t bother with preregistration.

Otherwise, start the event on time. If, say, 100 preregistered guests don’t show up, then allow 100 walk-ins to attend — and make them wait for a break, just like if they walked in late to a play or opera. In other words, Microsoft, have respect for the people who demonstrated their interest and sincerity by taking pains to follow the preregistration requirement and honor the schedule.

There were a lot of people at Heroes Happen Here, too; several hundred people went to the developer track. But I don’t recall people having to sit on the floor, or losing my seat, or being swept away by a human wave every time there was a break.

Event staff and organization: The event staff was friendly, but their organization was awful.

I registered for the developer track. When I checked in, I received the developer track evaluation form. But my name tag said I was in the IT professional track, and the agenda they gave me was for the IT decision maker track. As I noted previously, lots of us got the wrong agenda, which — coupled with the hotel serving lunch early — caused a mixup that helped to ruin an already boring seminar on SharePoint.

When I asked for the proper agenda, immediately after the first seminar ended (about two hours after the event started), they told me they had run out.

At Heroes Happen Here, I received all the proper materials. It appears Microsoft used the same contractor to manage both events (CRG Events), so how things got so messed up is beyond me.

The hotel and its staff: As I said before, the Westin Copley Place is a very nice hotel. And the hotel staff was excellent, from the housekeepers to the managers.

Trash was policed often (which was critical, given the mess created by soda cans, coffee cups, plastic cups, bag lunches and a bunch of worthless papers shoved into the event packet); the management was constantly checking with event staff, and on their own accord, to ensure things were going well; I did not see or hear a single problem related to the facility.

The food served was excellent and plentiful. Even the coffee — Starbucks — was of considerably better quality than one normally encounters at a continental breakfast.

The Radisson in Manchester, NH is also a nice hotel and also had a good staff, but it’s the difference between a Camry and a Maybach.

The swag: Yes, much of my disappointment is with Microsoft not offering fully functional copies of Visual Studio 2010. And I don’t think it’s too much to ask, in exchange for giving them my audience for eight hours and evangelizing on their behalf, to get a useful copy of the thing they’re flogging.

At Heroes Happen Here, they not only gave away copies of VS 2008 Professional, they also gave away a copy of Windows Vista Ultimate and evaluation copies of Windows Server 2008. Additionally, because SQL Server 2008 wasn’t ready by the time of Heroes Happen Here, Microsoft sent us, later, fully functional copies of SQL Server 2008 Standard.

I really have to believe that the same could have been done here. At best, Microsoft shouldn’t set an expectation like this and not follow through later. Or, they should state in the event FAQ that evaluation software only will be distributed, rather than saying that “information is not available at this time.”

The Heroes Happen Here software offering generated tremendous amounts of goodwill, at least from me. Launch 2010′s paltry 90-day evaluation disc, and the Desktop Optimization disc (PDF file) that I’ve already thrown in the trash, pretty much destroyed that goodwill in a fell swoop.

I’m not saying Microsoft needed to be as generous with software now as it was then. I would have been happy just getting a copy of VS 2010 Professional. I am saying that having three copies of VS 2010 Ultimate to give away, via drawing, to well over 500 people is actually counterproductive; it just rubs salt in the wound.

The presentations: Microsoft hires interesting and smart people to promote and support its products. It’s always great to hear from Chris Bowen, Jim O’Neil and Bob Familiar. And the remaining presenters — I’d tell you who they were, but I didn’t take notes at the time and I don’t have the right agenda to review — were affable and knowledgeable.

The keynote was a marketing pitch, plain and simple. The first session, on application lifecycle management, was entertaining but thin on practical examples. And the first SharePoint presentation was heavy on details about integrating old ASP.NET Web form applications, and completely deficient on Office programming.

Which was made more amusing since about three people, again out of about 500, held up their hands when the presenter asked who works in SharePoint. I was not one of them. Had he asked who does Office programming, I would have held up my hand — and I bet at least half the room would have, as well.

In other words, Microsoft wasted a lot of people’s time with that presentation; and even more with a second presentation on SharePoint that followed lunch.

Things got much better once Familiar, O’Neil and Bowen were allowed to do MSDN Northeast Roadshow-style presentations. But by then, my humor had largely turned.

Networking: As I said, opportunities to mix and mingle weren’t that great before or during the event, because there were simply too many people going in too many directions.

There was a mixer announced after the event, in the form of a Microsoft employee shouting it across the lobby and into the elevators. I wish they had told me about that ahead of time, so I could have planned for it. I would have come to Boston a day ahead and stayed over. At the very least, I wish they had not sapped all my patience by that time.

The building of relationships is what these events are supposed to be all about. But Microsoft completely forgot to structure the event to make that even possible.

What I take back: On Thursday, my exhaustion and exasperation came off as angry. In all honesty, at that time, that’s what I was: Angry. It was over as soon as I got to South Station, but I shouldn’t have been angry, period.

No one was operating with malice; at least, no one set out to make me wish I hadn’t attended. I am sure there are lots of reasons for things not going the way I wish they had; I am sure others consider Launch 2010 a major success; I am certain my perspective is neither authoritative nor omniscient. But I would be very interested in seeing the evaluation form results.

What I stand by: Pretty much everything. It wasn’t a very good event. It won’t make me quit .NET programming, and I did learn some useful stuff. But it sure lowered my opinion of Microsoft.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/the-visual-studio-launch-2010-boston-event-reconsidered

Related Posts

Live From The Microsoft Launch 2010 Event In Boston (65.4)

Recursively Listing Files In A Directory And Adding Their Names To A Text File In Visual Basic .NET (14.6)

Dynamically Adding JavaScript onLoad Event-Driven Scripts To ASP.NET 2.0 Templated / Master Page Content Pages (14.3)

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: Chris Bowen, cloud computing, developer tools, ethics, Jim O'Neil, marketing, Microsoft, mobile, MSDN, reputation, Sharepoint, Silverlight, Visual Studio, Windows Phone, Windows Server