dougv.com « Doug Vanderweide » MSDN

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

Parent-Child DropDownList Controls In ASP.NET Web Forms (VB.NET)

Doug Vanderweide — Sun, 25 Dec 2011 20:44:40 +0000

Some time ago I promised a formspring anon I would do a tutorial on parent / child DropDownList controls in ASP.NET Web Forms. At long last, I’m delivering. (From here on out, I will use “DropDownList” and “select list” interchangeably.)

Parent-child DropDownList controls means you have a parent, or main / master select list. Based on whatever selection is made in that first DropDownList, a second, “child” or “detail” select list is populated with relevant results.For example, if we had a database of cars, we might have a parent (master) DropDownList of manufacturers — Ford, Chevy, Toyota, etc. — and populate the child DropDownList with models from the selected manufacturer. So, if someone chose Ford in the parent select list, the child select list would automatically populate with choices such as Fusion, Mustang, Explorer, F-150, etc.

I’ll be demonstrating two different ways to accomplish this task, as well as a few variations on the first: First, binding with only SqlDataSource controls, which is by far the easiest way to proceed and will suffice for about 90 percent of applications; second, using code behind and CompareValidator controls, to cover all possible roadblocks.

Some notes before we proceed:

I’ll use the ZIP Code database I’ve been using for a while as the back-end data. I also have a separate table of USPS state codes I’m using as the parent data, to help illustrate that you can use several tables / data sources to fuel this solution, provided the keys that relate the data make sense to each data store. In other words, you can use a lot of different sources for your data, so long as the data is relational.
I’m going to use SQL Server, stored procedures and a connection string stored in my web.config file to access my data. I recognize that some people prefer to use SQL statements / LINQ and the like, or can only use Access / MySQL or other data stores. I really urge you to always use stored procedures, as they are way safer than inline SQL statements. As far as alternative data stores go, that should be a easy a fix as switching your code to use to the relevant ADO.NET ODBC classes, rather than the SQL Client classes.
This solution should work for ASP.NET versions 2.0 forward.

Example 1: Using SqlDataSource Controls

Most ASP.NET Web developers know about the SqlDataSource control and how to databind a DropDownList with that control. What they may not know is that, via the ControlParameter class, we can use the values in any other ASP.NET control(s) — including other databound controls — on the page as query parameters.

All you need to do is indicate, as properties of the ControlParameter, the ID of the control that will provide the key value for your child query, the property of that control (e.g., selected value, text, etc.) which should serve as the key, and the variable name that should be used in that query.

In our example, I have a select list named ddlParent, which will contain a list of state codes I get from a database table. Another select list, named ddlChild, will bind to a SqlDataSource control (named sqlChildDDL) that uses the selected value in ddlParent to retrieve proper records.

In my case, the stored procedure that will get the child records expects a parameter named “StateInitials”, the value of which comes from ddlParent and serves as the key for selecting the proper child records. By setting the AutoPostBack property of the parent DropDownList to true, I ensure the child DropDownList is rebound with the proper records each time the selected index of the parent list is changed.

Demo: http://dougv.net/demos/parent_child_dropdown/Example1A.aspx

Note that we can use any ASP.NET control on the page as a ControlParamter, and we can use any of that control’s properties as a parameter value, regardless of data type.

In other words, we could have a textbox on the page and use its Text property to let people type in free-text terms. (That’s a huge security risk, but it can be done.)

Or we could even use a static control with a non-text property, such as the Parent value of a Label control.

Of course, we need to exercise care here; any parameter value we send to a database query has to be the right data type / something the database store understands how to parse. The point is, ControlParamter is a powerful tool; respect it and it will open a number of possibilities.

Now that we have a parent-child select lists pair, how do we use that data to power some other control’s data? Simple: We just use the SelectedValue of the child DropDownList as the ControlParamter value for another SqlDataSource — in this example, it will bind to a GridView that gives the selected town’s ZIP Code, CityLatitude and CityLongitude.

All we need to do is add the GridView and its SqlDataSource, plus set the AutoPostBack property for ddlChild to true, so that the GridView’s values will change any time ddlChild’s selected index is changed.

See this in action: http://dougv.net/demos/parent_child_dropdown/Default.aspx

Example 1B: A Little Code Behind To Clean Things Up

If you play with the demo above, you’ll notice a problem: Any time you change the selected ListItem in ddlParent, the ListItems in ddlChild are updated, but not the data in the details GridView.

In other words, if you select a new state from the parent select list, the town values in the child select will change to the appropriate entries, but the GridView retains the old data from the previously selected town. Only choosing a new town from the child select list will update the GridView.

That happens because although ddlChild has been populated with new ListItems, the SelectedValue of ddlChild hasn’t been changed. Changing the SelectedValue is an act that must take place within ddlChild, not ddlParent.

In other words, the event that triggered the page to post back was a change in ddlParent’s selected value, not ddlChild. Until we explicitly instruct ddlChild to update its selected value, either programmatically or by hand, as far as ASP.NET is concerned, it retains the last SelectedValue, regardless of the fact that its ListItems have changed.

This behavior is by design and as it should be. But it does make for an annoyance we need to address.

Fortunately, we can fix this with just a little codebehind; namely, an event handler that fires on ddlParent’s OnSelectedIndexChanged event. That handler will:

Rebind ddlChild to its SqlDataSource, which will now contain the correct town list.
Set the SelectedIndex of ddlChild to 0, or the first town in the new list.
Rebind the GridView’s SqlDataSource so it draws from the first town in the updated town list.

Sub ddlParent_selectedIndexChanged(Sender As Object, E As EventArgs) Handles ddlParent.SelectedIndexChanged
	ddlChild.DataBind()
	ddlChild.SelectedIndex = 0
	sqlZipDetails.DataBind()
End Sub

Demo: http://dougv.net/demos/parent_child_dropdown/Example1B.aspx

This pretty much solves our data latency problem, but it adds duplicate queries to the process and thus is inefficient. We can do a better if we get more code-intensive.

Example 2: Using Code Behind And CompareValidator Controls

To streamline the process, reduce database queries and handle potentially bad inputs, we can use code behind to populate our DropDownLists and GridView, plus use CompareValidators to ensure we have legitimate data before sending our database queries.

We’ll bind records to a SqlDataReader, then use that reader to populate the DropDownLists and, where appropriate, the detail GridView. Additionally, we’ll use CompareValidators to ensure that the users have selected a valid option from each DropDownList.

First up, we need to create the DropDownLists and GridView. Notice that both DropDownLists begin with a single, default ListItem with a value of 0.

That’s because our valid options, once this list is populated, will never be zero; as a result, we can test with the CompareValidators whether the selected value of either DropDownList is 0. If it is, we know we have an invalid choice; otherwise, we expect the choice to be valid.

We have several subroutines needed to power this solution.

First, we need to initially populate the parent DropDownList; we’ll do that in the Page_Load subroutine, checking whether this page is a postback. (We don’t want to repopulate the parent select list on every page refresh; if we do, we won’t ever be able to change the child select list’s values, since the selected index of the parent DropDownList becomes 0, automatically, every time it is databound.

Sub Page_Load(Sender As Object, E As EventArgs) Handles Me.Load
	If Not Page.IsPostBack Then
		ddlParent_dataBind()
	End If
End Sub

The process of binding the parent DropDownList is just connecting to the database server, populating a SqlDataReader with records, binding that to the parent DropDownList and indicating which fields should be used for text and values of the resulting ListItems.

Sub ddlParent_dataBind()
	Dim objConn As New SqlConnection(ConfigurationManager.ConnectionStrings("MyConnection").ConnectionString)
	Dim objCmd As New SqlCommand("GetStates", objConn)
	objCmd.CommandType = CommandType.StoredProcedure

	Dim objReader As SqlDataReader

	objConn.Open()
	objReader = objCmd.ExecuteReader()

	If Not objReader.HasRows Then
		ddlParent.Items.Clear()
		ddlParent.Items.Add("No records found.")
		ddlParent.Enabled = False
	Else
		ddlChild.Enabled = True
		ddlParent.DataSource = objReader
		ddlParent.DataTextField = "StateName"
		ddlParent.DataValueField = "StateCode"
		ddlParent.DataBind()
		ddlParent.Items.Insert(0, New ListItem("Select A State ...", "0"))
	End If

	objConn.Close()
	objCmd.Dispose()
	objConn.Dispose()
End Sub

We bind data to the child select list in a similar way, except we’re going to get some sort of key value from the parent DropDownList. So we pass that in as a parameter.

Sub ddlChild_dataBind(strKey As String)
	ddlChild.Items.Clear()

	Dim objConn As New SqlConnection(ConfigurationManager.ConnectionStrings("MyConnection").ConnectionString)
	Dim objCmd As New SqlCommand("GetZIPCodes", objConn)
	objCmd.CommandType = CommandType.StoredProcedure

	objCmd.Parameters.Add(New SqlParameter("StateInitials", SqlDbType.Char, 2))
	objCmd.Parameters("StateInitials").Value = strKey

	Dim objReader As SqlDataReader

	objConn.Open()
	objReader = objCmd.ExecuteReader()

	If Not objReader.HasRows Then
		ddlChild.Items.Clear()
		ddlChild.Items.Insert(0, "Error getting towns list from database")
	Else
		ddlChild.Enabled = True
		ddlChild.DataSource = objReader
		ddlChild.DataTextField = "CityName"
		ddlChild.DataValueField = "ZIPCode"
		ddlChild.DataBind()
		ddlChild.Items.Insert(0, New ListItem("Select A Town ...", "0"))
	End If

	objConn.Close()
	objCmd.Dispose()
	objConn.Dispose()
End Sub

And binding the GridView data is pretty much more of the same.

Sub gvDetails_dataBind(strKey As String)
	Dim objConn As New SqlConnection(ConfigurationManager.ConnectionStrings("MyConnection").ConnectionString)
	Dim objCmd As New SqlCommand("GetCityDetails", objConn)
	objCmd.CommandType = CommandType.StoredProcedure

	objCmd.Parameters.Add(New SqlParameter("ZIPCode", SqlDbType.Char, 5))
	objCmd.Parameters("ZIPCode").Value = strKey

	Dim objReader As SqlDataReader

	objConn.Open()
	objReader = objCmd.ExecuteReader()

	gvDetails.DataSource = objReader
	gvDetails.DataBind()

	objConn.Close()
	objCmd.Dispose()
	objConn.Dispose()
End Sub

Note that in all this databinding, I am not checking for exceptions, such as failure to connect to the database, a problem with the stored procedures, etc.

As I have said before, what makes for workable error trapping on your end is impossible for me to know, which is why I am not including it here. You should always check for errors. Don’t trust your programs won’t break; expect them to break. How you do that is up to you, but you definitely should prepare for failure.

We’ve got one more non-event subroutine to consider before we get into the action: A way to reset the GridView when we don’t have a valid child DropDownList selection.

To do that, we’ll simply set the DataSource of the GridView to nothing (null), then bind it; when a GridView is bound to a null, it is thus empty and, absent having its EmptyDataTemplate or EmptyDataText properties set, simply doesn’t render.

(I recognize that using nulls in this way is lazy. An alternative is to toggle the visibility of the GridView so that it only shows when we know we have good data, but that’s wordier and yes, I am being kind of lazy here.)

Sub gvDetails_reset()
	gvDetails.DataSource = Nothing
	gvDetails.DataBind()
End Sub

OK, with the mechanical parts of our code out of the way, we can handle changes to the selected item indexes of both the parent and child lists.

In the case of a parent select list change, we always know that whatever information is currently in the detail GridView will be outdated. So we’ll reset it, and we’ll rebind the child DropDownList if the selection in the parent DropDownList is valid (which we check with the relevant CompareValidator).

Sub ddlParent_selectedIndexChanged(Sender As Object, E As EventArgs) Handles ddlParent.SelectedIndexChanged
	cvParent.Validate()
	If cvParent.IsValid Then
		ddlChild_dataBind(ddlParent.SelectedValue)
		ddlChild.SelectedIndex = 0
	End If
	gvDetails_reset()
End Sub

When the child DropDownList’s selected index is changed, one of two things are true: Either the selection isn’t valid, in which case we reset the detail GridView, or it’s time to populate the details GridView with a new town’s information.

Sub ddlChild_selectedIndexChanged(Sender As Object, E As EventArgs) Handles ddlChild.SelectedIndexChanged
	cvChild.Validate()
	If cvChild.IsValid Then
		gvDetails_dataBind(ddlChild.SelectedValue)
	Else
		gvDetails_reset()
	End If
End Sub

You can see all this in action here: http://dougv.net/demos/parent_child_dropdown/Example2.aspx. You can also copy and paste relevant code from there. I distribute code under the GNU GPL version 3.

Tags: drop down / select list, Microsoft, MSDN, ZIP Code database

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

De-Spamming My Twitter Followers

Doug Vanderweide — Wed, 16 Mar 2011 17:09:26 +0000

I’ve recently despammed my Twitter follower list. If you were following me, and now find yourself blocked, you have my apologies. Please send me an e-mail and I’ll unblock you.

This provides me with a great opportunity to discuss my attitude about Twitter followers and following.

Generally speaking, if someone starts following me, I follow them. If I follow someone, I usually expect to be followed back, and likely will stop following, after a week or so, someone who isn’t following me.

Exceptions to this rule are announcement accounts (e.g, @MSDN, @GoogleCode, @APStylebook) and major celebrities (guideline: someone whose identity has been verified by Twitter, e.g. @SethMacFarlane).

I may decide not to follow someone, but that doesn’t mean I mind them following me. I prefer a two-way street, but that’s not to say that people who only want to listen aren’t welcome to follow me.

I do mind being followed by Twitter accounts that are:

Obviously meant only to spam. If all a follower does on Twitter is solicit business, please keep me out of it.
Astroturfing. This one is sometimes a judgment call, but if a follower’s tweets are about things other than the kinds of things I am talking about (or the follower hasn’t tweeted at all), and that tweeter is following a lot of other people with whom he is not communicating / has no common interests, I’ll probably toss him into this category and block him.
Patently offensive. Profanity, sexually suggestive comments, edgy humor; these are all fine. Trolling and hating are not.
Malicious bots. I am followed by a handful of IT bots; so long as they’re reposting / harvesting relevant info, I’m OK with that. All other bots can GTFO.

Tags: Google, MSDN, reputation

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

Custom ErrorDocuments Available For Download

Doug Vanderweide — Tue, 05 Oct 2010 18:25:16 +0000

After writing so much about the ASP.NET cryptographic padding oracle exploit, and the recommended workaround of a static error document, it dawned on me that I should probably make some custom error documents for my domains.

And then I decided I should share them. So, if you’re so inclined, you can download the custom error documents I use on this site. I release all code under the latest version of the GNU GPL.

I’ve created pages for 401 (unauthorized), 403 (forbidden), 404 (not found) and 500 (internal server) HTTP errors. Here’s how they look (click thumbnails for larger image):

I designed these to be valid XHTML 1.0; to appear well in all screen resolutions from 1024 x 768 and greater; and to appear the same on most Web browsers. (Of course, I exclude Internet Explorer prior to version 7 from that list.)

This little exercise also gave me a chance to play with the Google Font API. There aren’t a lot of fonts available yet, but using the API couldn’t be simpler.

Instructions on implementing custom error document on Apache can be found here. Microsoft documents how to add customError files to your ASP.NET web.config file here.

All links in this post on delicious: http://www.delicious.com/dougvdotcom/custom-errordocuments-available-for-download

Tags: Apache, Google, IIS, Microsoft, MSDN, 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

New England GiveCamp 2010: What A Great Experience

Doug Vanderweide — Wed, 16 Jun 2010 21:05:47 +0000

The first New England GiveCamp was this weekend at Microsoft’s Northeast Research and Development building in Cambridge, MA, and it was, by far, one of the most rewarding experiences I’ve had in the 15 years I have been professionally coding.

About 100 technical and non-technical volunteers spent the weekend of June 11-13 writing code for charities. Most projects were Web site upgrades — either installing a content management system, or extending that system to do something it didn’t do before, such as collecting very specific data, integrating with a customer relationship management tool, etc.

Other projects were more complex. For example, my project was data normalization and version control.

I was assigned to the Goshen Land Trust, a charity that protects open and green space in Goshen, CT. My team members were Kriss Aho and Pat Tormey, both from the Boston area; and Chris Craig, the president of GLT.

Prior to last weekend, GLT tracked all its customer relationships in Excel spreadsheets. They do their accounting in Quickbooks.

If someone was a volunteer, his name went into the volunteer spreadsheet. If he owned land, his name was in the landowner spreadsheet. If he was a land or money donor, his name went into another spreadsheet. And so on, and so on; this story has been told a thousand times before, we all know it by heart.

And, of course, there were several versions of each of these spreadsheets out there: They were exchanged back and forth via e-mail, meaning no two copies of the same spreadsheet were alike. Again, stop me if you’ve heard this one before.

Finally, donor payments are managed entirely separate from the spreadsheets, via entries into Quickbooks. So there’s a completely different store of around 800 mostly duplicate names in Quickbooks, too, which isn’t easily compared to a spreadsheet of about 2,000 names.

So we had to figure out a way to impose some version control on these sheets; we had to create a master data store, so we could have an authoritative source of customer relationship information; and we had to sync customer information in Quickbooks to match the master data store.

Sounds like fun, I know. It actually was, after it stopped being awful.

If It’s Half-Broke, Fix The Half That’s Broke

Kriss Aho and Chris Craig, Goshen Land Trust, at New England GiveCamp 2010.

We wound up doing the real scoping for this project on Friday night, where the initial project parameters changed from a simple training exercise to the data normalization project we wound up doing.

My immediate thought, as we were discussing how to tame these spreadsheets, turned to CiviCRM. It’s an open-source, Web-based customer relationship management tool that is designed specifically for nonprofits, and that would have fit Goshen Land Trust’s needs nicely.

But that idea suffered a few significant flaws. The biggest problem was, none of the end users have any experience with CRM software in the first place, nonetheless CiviCRM, and we didn’t want to force a solution on to people who hadn’t bought in to the solution beforehand.

In other words, if Excel was getting the job done, except for the fact that none of the data jived among the sheets, then let’s stick with Excel, or at least spreadsheets, since everyone is comfortable with that.

We would simply combine all the current sheets into one “master” spreadsheet. Every person would be a row; every conceivable relationship and bit of information about that person would be a column.

Was this the cleanest, most elegant solution to the problem? No. But it’s one that meets the client’s needs and expectations, and it’s something we could do over the weekend. Or, to be more specific, that Kriss could do over the weekend. I got a different assignment; more on that in a moment.

In a perfect world, we would have discussed the project sooner and given the Goshen Land Trust a chance to check out CiviCRM. But again, Chris said he was OK with sticking with Excel, so long as the versioning issue was fixed; and Kriss could combine the sheets with minimal data mangling and need for cleanup by hand.

So the master data store problem was fixed. Now we needed to address version control. The answer to that was Google Docs.

Since the spreadsheet in question is “flat” — that is, one sheet, with many columns reflecting every relationship — we didn’t have to worry about macros, VBA scripts or other Excel-only attributes.

We also didn’t need complex user permissions: One guy owns the sheet, a few people need to be able to edit it and a few more need to be able to look at it. Google Docs has that built-in.

So we could just pop our master sheet into the cloud, set up some Google accounts and everyone would have access to one copy of one thing. Problem No. 2 solved.

Quickbooks, How Do I Hate Thee? Let Me Count The Ways …

I'm smiling here, but by the time this photo was taken -- aroud 4:30 pm on Saturday -- the Quickbooks SDK had shattered all my hopes and dreams. Kriss Aho, me, Chris Craig of Goshen Land Trust and Pat Tormey, our project leader. Via jflinskey on Flickr.

Problem No. 3 fell to me: How do we synchronize the contact information being kept in the spreadsheet with the customer data being stored in Quickbooks?

My kingdom for a unique key, is the answer.

Because syncing records in two data stores was never a consideration before, GLT’s roughly 800 Quickbooks customers were recorded in ways that generally weren’t easy to match against the spreadsheets they maintained. I tried a mapped Excel import into Quickbooks of data in the spreadsheets, and came up with what was at least a 70 percent match failure rate.

It quickly became apparent I was going to need a unique key. The question was, how could I get a key other than Customer Name out of Quickbooks, since customer name is the only unique key exposed by built-in import / export functions, and clearly that wasn’t going to work?

The answer was the Quickbooks SDK, one of the sorriest, worst-documented excuses for a programming tool I’ve ever encountered. The only way to get access to Quickbooks’ internal unique identifier for customer objects is via the SDK.

My suggestion: If you ever need to do a Quickbooks SDK project in a weekend, and you haven’t used the Quickbooks SDK before, don’t bother.

The Quickbooks SDK provides, at the desktop level, two ways to get data.

The first, oldest and the one I chose was qbXML, which is basically SOAP: You present an XML request, you get an XML response. I have experience working with XML-RPC, Web services and XML in general, so this seemed the smart way to go.

The other is QBFC, which is more like writing a traditional object-based program using classes, methods and properties. This is the way I would have preferred to go, had the Quickbooks SDK’s documentation made that an option.

When I call the Quickbooks SDK “poorly documented,” what I mean is that it completely lacks object or entity references. As in, don’t bother trying to look up what classes, methods, properties or XML markup you should use, or what arguments any of them take. It isn’t written down anywhere. Not in the SDK documentation, not on Intuit’s Web site, not on the Interweb. Apparently, the Illuminati are keeping it a secret.

To figure out what you should do for a Quickbooks SDK project, you need to reverse-engineer a bunch of sample projects that come in the SDK. There is a “jump start” PDF that explains the basics of making requests and handling responses, but they’re written in Visual Basic 6, apparently by some junior-college student who’s being way too verbose in order to show his work to the professor.

(And yes, you guessed it: The Quickbooks SDK is straight-up COM+. You must install at least one DLL on each machine that wants to run an SDK application.)

Thankfully, there are plenty of XML, XSLT and similar sample files in the SDK for both qbXML and QBFC, covering virtually anything you could want or do; so one can hammer out a solution that’s a mashup of a provided sample.

Unless time and experience with the SDK aren’t luxuries you enjoy. Which was certainly the case for me this weekend.

My original goal was to create, in Quickbooks itself, a macro that would directly grab the online spreadsheet (via JSON requests to the Google Spreadsheets Data API), match up my records, correct any customer contact info that is wrong in Quickbooks with information from the online spreadsheet, and report results.

Cue Robert Burns.

It was everything I could do over the weekend to get Quickbooks to give me the customer list as an XML file. And that XML file has multiple object levels, but no schema definition or namespace declaration available anyplace, either. Again: Worst. SDK. Ever.

So now I need to apply XSL to flatten it out, for purposes of comparing it to the online spreadsheet.

Needless to say, I’m still working on the project. My new plan:

Create my record-flattening XSL.
Have my program run standalone.
Compare whatever is in the Quickbooks Customer List against the online spreadsheet.
1. Any unique ID that is in the Quickbooks Customer List, but not in the online spreadsheet, is listed in a new Excel sheet, for manual updating.
2. Any unique ID that is in Quickbooks, but has address / contact information that doesn’t match the online spreadsheet, is reported to a new Excel sheet, for manual updating.

I figure I’m about six hours out from being done. And I will deliver this. Because now, it’s personal. And when I’m done, I’m going to blog about it, so the next poor soul has a head start.

The Experience Was Amazing

Pat Tormey, my project leader, at New England GiveCamp 2010. Taken about two hours before the event's end on Sunday, he's pretty relaxed for a guy who was just told the project wouldn't be done in time. Just another in a long list of reasons to like him.

OK, I admit I’m being overly dramatic about the Quickbooks SDK. But it was such an intense experience, being part of New England GiveCamp, that you will have to grant me some poetic license.

Cambridge, MA, the MIT campus and the NERD building are completely awesome.

The entire city is a visual feast: architecture, art, people, happenings; you name it, there’s something interesting to look at anywhere you go, at all hours.

The Charles River has become quite a centerpiece, too. On Friday and Saturday nights I opted to walk from NERD to the Hyatt Regency Cambridge hotel, where I was staying, which are about two miles apart on Memorial Drive.

That walk could not have been more pleasant. The Boston skyline at night is beautiful, and the buildings I passed on the way were all alive with the sounds of music and conversation and celebration.

Every morning, I took a cab in to prevent getting sweaty; on Saturday morning, I passed Harvard crew practice. (Memo to them: Time for a Web site redesign.)

I know, I should have taken pictures. The entire weekend, I kept saying, “next time.” Until I ran out of next times. So, next time.

The Hyatt is a very nice hotel, too. The glass elevators are kind of cool; the bed was completely awesome, and the room was more than sufficient in size for one person.

I did give the restaurant / lounge a try on Saturday night; they charged me $17 for 32 oz. of beer, served in a mimosa glass and milk pitcher, which I thought was pretty silly. They also messed up my hamburger order, but gave it to me for free as a result.

I made the mistake of reserving a room at the last minute — priceline.com completely came up short on reasonable, affordable alternatives — so it was hard to get the Microsoft corporate rate, but after a series of phone and e-mail exchanges, I managed to get in at the last minute.

So I would happily recommend the Hyatt Regency if you’re staying in the Boston area. They were very accommodating, no pun intended.

Such Interesting People And Causes, Too

The people at GiveCamp were pretty interesting, too: Both the developers and the charities.

I reconnected with Greg Howe, who I went to college with and who co-manages the Bangor Area .NET Development group. Greg is exceptionally well-versed in Web security and gave a talk during the event.

I met Alexander Lee, whose charity, Project Laundry List, advocates line-drying clothes as a green technology; it sounds silly to a country boy like me, but in many places in the world, a clothes line is a practical, or political, impossibility.

I wanted to meet, but couldn’t manage it, Spare Change News, a newspaper produced and distributed by the homeless, which I thought was probably one of the most interesting ideas I’ve heard in a while; rather than trying to get the homeless to not be homeless, it aims to provide the homeless with the information and financial support to meet their needs.

The event was full of incredible people doing incredible things. You couldn’t help but be inspired and driven to give your best.

I figured that at worst, the GiveCamp experience would be an opportunity to help out some people who needed it and to jabber with some like-minded souls. Turns out it was that and more.

It plain feels good to have made a difference to someone else. It plain feels good to have been in the company of unselfish people for a weekend. It plain feels good to have been in a beautiful place for a weekend. And it plain feels good to have been thanked by people doing largely thankless work.

Count on me for New England GiveCamp 2011 and beyond.

All links in this post on delicious: http://delicious.com/dougvdotcom/new-england-givecamp-2010-what-a-great-experience

Tags: elegance, GiveCamp, Google, Jim O'Neil, marketing, Microsoft, MSDN, Quickbooks, Web Services, XSLT

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