Wooley's Wonderings

LINQ in Action going to press

jwooley — Mon, 21 Jan 2008 08:16:00 GMT

At long last, the process of doing my first book is coming to a close. I started this project last March. Through the process we had to revisit our work numerous times, including each time a new CTP or Beta drop came. For me, 10 months, and Fabrice 2 years later, we found out this week that the book is going to press.

What does this mean for you, if you purchased the eBook, the final version is available now. Additionally, the samples are available online in both C# and VB. We are also making three chapters available for free if you are considering the book, but not sure yet.

If you purchase the hard copy from Manning, we understand that it should be in around the first of February. This should mean that it will be shipping from the online outlets, like Amazon by the middle of February.

I hope you find the book as rewarding to read as it did for us to write.

crossposted from www.thinqlinq.com

Annoucing ThinqLinq.com

jwooley — Thu, 10 Jan 2008 07:46:00 GMT

You may have seen me present it at a speaking engagement. You may have watched the podcasts. You may have even downloaded the sample application. Now you can see it in action.

ThinqLinq.com is now live.

The site was designed completely in VB with LINQ as the data access mechanism. The base application was built in 2 hours from not knowing RSS to being able to import a RSS feed, displaying it on a form and producing a new feed from the imported data. The site is a testimate to the power of LINQ and the RAD capabilities that it brings. Head on over to the site and check it out.

LINQ In Action Samples online

jwooley — Mon, 17 Dec 2007 16:41:00 GMT

It's the time of the year when we put the finishing touches on our decorations. As Fabrice annouced, we are in the same mode with our book. The text is almost ready, but you won't be able to get the hard copy under your tree this year unfortunately. If you can't wait, you can download the samples in both C# and VB now. We'll let you know when the book starts shipping. If you don't want to wait, you can pre-order it through Amazon, or purchase the ebook/print combo directly through Manning.

More on VS 2008 breaking changes

jwooley — Mon, 03 Dec 2007 05:49:00 GMT

In addition to the items I mentioned in my previous Beta 2 - RTM breaking change list, I found a link on the VS 2008 samples page that a whitepaper has been issued on this. Download the whitepaper at this link: http://download.microsoft.com/download/d/7/e/d7eeb256-5789-411c-a367-c9fda05c2b1c/LINQ_to_SQL_Beta_2_to_RTM_Breaking_Changes.docx

In addition, there is a whitepaper specific to breaking changes between VB 2005 and VB 2008 available here.

Technorati tags: VB Visual Studio

Projecting XML from LINQ to SQL

jwooley — Tue, 20 Nov 2007 07:08:00 GMT

Among the new cool features in Visual Studio 2008, one of the best may be the XML Literal support with VB 9 and LINQ. In my last post, I mentioned some changing features from the Beta to RTM. One that could easily be overlooked is a change to the way LINQ to SQL can now directly project into XML literals.

Through the Beta cycle, there was an issue with projecting XML elements directly from a LINQ to SQL query. If you haven't seen LINQ to SQL with XML, here's a code sample that explains what I'm referring to:

Dim dc As New LinqBlogDataContext
'Formulate the Query to get the last 10 blog posts
Dim query = (From p In dc.PostItems _
                      Order By p.PublicationDate Descending _
                      Take 10 _
                      Select p).ToArray

'Create a root Site node with 10 child "item" nodes.
'Each node will be filled in through a LINQ query
Dim fooShort = _
<site>
        <%= From p In query _
                 Select _
             <item>
                  <title><%= p.Title %></title>
                  <link>http://ThinqLinq.com/Default.aspx?Postid=<%= p.Id %></link>
                  <pubDate><%= p.PublicationDate %></pubDate>
                  <guid isPermaLink="false">42f563c8-34ea-4d01-bfe1-2047c2222a74:<%
p.Id %></guid>
                  <description><%= p.Description %></description>
                </item> %>
</site>

In this code, I'm performing two queries. The first one sets up the LINQ to SQL query and pre-fetches the results into an Array. In the beta builds, if we didn't include the pre-fetching ToArray, the second query which projects the results of the first into individual <item> nodes. What is the difference between these queries? The first query uses LINQ to SQL and projects results directly from the database. Because we pre-fetch the results into an array of objects, the resulting query only uses LINQ to Objects rather than the direct LINQ to SQL implementation.

With the final RTM of Visual Studio, we no longer need to pre-fetch the results from the query. Instead, we can directly project our desired XML from the select statement without needing the intermediary step. Here is the revised code. Notice, we can now perform the same result with a single LINQ query rather than two.

Dim fooNew = _
<site>
       <%= From p In dc.PostItems _
                Order By p.PublicationDate Descending _
                Take 10 _
                Select _
           <item>
                <title><%= p.Title %></title>
                <link>http://ThinqLinq.com/Default.aspx?Postid=<%= p.Id %></link>
                <pubDate><%= p.PublicationDate %></pubDate>
                <guid isPermaLink="false">42f563c8-34ea-4d01-bfe1-2047c2222a74:<%= p.Id %></guid>
                <description><%= p.Description %></description>
            </item> %>
</site>

The result is more concise. You may find you want to continue separating your query definition from your XML creation in order to improve maintainability. If this is the case, simply keep the first code sample and remove the call to .ToArray. Because LINQ to SQL is composable, you can separate the queries into two code sets. When the query is evaluated, the two expressions will be combined into a single query to the database and the projection will continue to work.

Enjoy working with VB 9 and XML. In my opinion it is one of the killer features of Visual Studio 2008. If you give it a try, I think you might find the same.

Technorati tags: linq, VB Visual Studio XML

Visual Studio 2008 (Orcas) Changes from Beta 2 to RTM

jwooley — Tue, 20 Nov 2007 06:53:00 GMT

I've just updated the ThinqLinq proof of concept site for the Visual Studio 2008 release that came out today. If you're following the sample application, or are looking for a sample VB 9 implementation of LINQ in a web site, check out the download at http://devauthority.com/files/13/jwooley/entry101097.aspx. In case you are interested, here are the changes that were necessary to move from Beta 2 to the RTM. (The first two items are repeats from my post earlier today).

Open the DBML file as XML and change the UTF encoding from 16 to 8. Otherwise the compiler will complain about the DBML file's format. The error you will likely see will be "Build failed due to validation errors in [MyFile.dbml]. Open the file and resolve the issues in the Error List, then try rebuilding the project." When you open the file, you won't see errors in the error list. Just change the encoding and you should be good.
Replace the Add methods with InsertOnSubmit. Likewise, change Remove to DeleteOnSubmit. You may be able to do a global search and replace on this, but be careful not to make changes to any IList object implementations, only LINQ to SQL ones.
SyndicationFeed.Load removed the option to pass in a URI. Instead, I used SyndicationFeed.Load(New System.Xml.XmlTextReader(UrlString)).
The SyndicationFeed's Item PublishDate property is changed to the new DateTimeOffset type rather than the simpler DateTime. As a result, get the date from the PublishDate.Date property.
When projecting XML elements as part of a LINQ to SQL query, you no longer need to pre-fetch the results into an array. I'll make a separate post on this item.

That's all I've found so far. I've already updated both the ThinqLinq site and the samples for the upcoming LINQ in Action book. I'm sure I've missed something, but so far, the upgrade is relatively easy this time around. The IDE does appear to be running faster as well.

Technorati tags: linq, orcas Visual Studio

VS 2008 RTM and the .NET Framework 3.5 Shipped

jwooley — Mon, 19 Nov 2007 19:09:00 GMT

It's offical, Soma annouced on his blog that the 3.5 .Net Framework along with Visual Studio 2008 have shipped. I have been excited by the things coming with this release since PDC 2005 and am glad to finally work the the official bits. I am aware of a couple breaking changes between the Beta 2 and RTM, and will try to keep you updated as I find more items.

The biggest changes to be aware of in regards to LINQ to SQL are the following:

Open the DBML file as XML and change the UTF encoding from 16 to 8. Otherwise the compiler will complain about the DBML file's format.
Replace the Add methods with InsertOnSubmit. Likewise, change Remove to DeleteOnSubmit. You may be able to do a global search and replace on this, but be careful not to make changes to any IList object implementations, only LINQ to SQL ones.

There are a couple other minor updates that may catch you off-guard. I'll update you once I've had a chance to play with the final bits.

Technorati tags: linq, orcas Visual Studio

Feedburner access to Wooley's various Wonderings

jwooley — Fri, 09 Nov 2007 23:24:00 GMT

I have set-up several feedburner syndication options for my postings for your enjoyment. Feel free to move your aggregator over to those versions of the feeds and show me how much you digg what I have to say. Here's the links for you:

Wooley's Wonderings: My main feed
Jim's Samples and Presentations: My downloads and sample applications from my presentations. Subscribe here to get updates whenever I add new samples.

I have a bunch of things I want to discuss from my DevConnections trip, so stay tuned.

VS 2008 Beta 2 VPC images will timebomb on 11/1/2007

jwooley — Fri, 26 Oct 2007 22:13:00 GMT

If you downloaded the VPC image version of Visual Studio 2008 beta 2, make sure to back-up your data and move anything off of the Team Foundation Server before November 1, 2007. I was just informed that the images will be time bombing on November 1 2007 rather than the originally intended March 15, 2008 date. If you don't download it now, you may not be able to retrieve your projects. More information is available at the VS 2008 beta 2 download site. If you installed the stand-alone version, you should be ok.

Creating HTML emails using VB 9 and LINQ

jwooley — Wed, 24 Oct 2007 22:41:00 GMT

Today, I'm not looking at sending mass spam using LINQ to pull a list of recipients. I'm actually referring to the ability to generate the message body using XML Literals. Using the System.Net.Mail.MailMessage object, we can easily send emails to an SMTP server.

The body of the email can either be plain text or HTML. Dynamically generating the text is often a laborious task involving a string builder and lots of method calls. The body corresponds to the body portion of a HTML page. If you use well formed XHTML in the body, you are actually generating a specialized version of XML. Once we are working with XML, we can use XML Literals in VB to format our output.

I recently had to do this on a project to send lists of updated values from an external source. In the body, I needed to dynamically fill a HTML table with the new values. The table consists of 4 columns: State, County, Limit, Effective Date. I begin by laying out the content in a HTML editor (like Visual Studio 2008...) Here's the results:

<body>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Curabitur eros purus, suscipit ac, pulvinar vel, aliquet vehicula, pede. Duis eros dolor, iaculis non, aliquam sed, tincidunt ac, diam.
    <table>
      <tr><th>State</th>
            <th>County</th>
            <th>New Limit</th>
            <th>Effective Date</th>
      </tr><tr><td>XX</td>
                     <td>Foo</td>
                     <td>$123</td>
                     <td>1/1/2000</td>
               </tr>
    </table>
</body>

I know what you must be thinking by now: Gee Jim, how could you come up with such a beautiful page. As Bones would say, "D@mmit Jim, I'm programmer not a designer." We'll keep it clean for now to focus on what is yet to come.

Realize that our body tag is actually the root of a well-formed XML document. As such, we can copy it as a template directly into our tool (which is a console application by the way), add a reference to System.Linq and System.Xml.Linq, and paste it into our VB module assigning a variable, let's call it "body" to the XML.

While we're at it, we'll go ahead and insert new rows into the table based on the results of an object query. In this query, we'll iterate over the records we are adding which is an IEnumerable(Of Limit). We'll project a new row (<tr>) for each object in our iteration. Rather than imperatively iterating, we'll use LINQ's declarative syntax In addition, we'll insert our values using the <%= %> place holders. Here's the resulting declaration:

Friend Shared Sub SendUpdate(ByVal newItems As IEnumerable(Of FhaLimit))
Dim body = _
<body>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Curabitur eros purus, suscipit ac, pulvinar vel, aliquet vehicula, pede. Duis eros dolor, iaculis non, aliquam sed, tincidunt ac, diam.
    <table>
      <tr><th>State</th>
            <th>County</th>
            <th>New Limit</th>
            <th>Effective Date</th>
      </tr><%= From limit In newItems _
                      Order By limit.State, limit.CountyName _
                      Select <tr><td><%= limit.State %></td>
                                       <td><%= limit.CountyName %></td>
                                       <td><%= limit.Units1.Value.ToString("c0") %></td>
                                       <td><%= limit.LimitTransactionDate.ToShortDateString %></td>
                                </tr> %>
    </table>
</body>

If you've coded ASP.NET, the resulting declaration should look very familiar. Realize that this is being done in a VB module in a console application. We are not coding in a .ASPX file! The resulting maintainability of this code is much better than the old way using string builders or XSLT.

To finish off the task, we are going to send the message with our new XHTML body. This is very easy with .NET as well.

Dim message As New System.Net.Mail.MailMessage("from@ThinqLinq.com", "to@ThinqLinq.com", "Limits Updated", body.ToString)
message.IsBodyHtml = True
Dim server As New System.Net.Mail.SmtpClient(My.Settings.SmtpServer)
server.Send(message)

There you go, a quick and painless way to create HTML emails using VB 9 and LINQ. Let me know what you Thinq.

Technorati tags: linq, orcas, vb, xml

Adding RSS posts to ThinqLinq using System.ServiceModel.Syndication.SyndicationFeed

jwooley — Fri, 12 Oct 2007 04:58:00 GMT

When I originally started the ThinqLinq project I began by loading the RSS feed from my DevAuthority blog, and iterating over the results adding them to the PostItems table in the data context. With LINQ this is relatively easy. Loading the XML from the feed is done with a single line:

Dim Feed As System.Xml.Linq.XDocument = XDocument.Load("http://devauthority.com/blogs/jwooley/rss.aspx")

The xml document consists some basic informational elements which are not terribly important in this instance as we are only pulling from a single blog. Following the initial elements, the document contains a series of "item" elements that contain the actual post information. We can easily query the document and return an IEnumerable(Of XElement) object that we can iterate over and create new post items. Below is an excerpt from my original implementation.

For Each post As XElement In Feed...<item>
    Dim DataPost As New LinqBlog.BO.PostItem
    DataPost.Author = "Jim Wooley"
    DataPost.Description = post.Element("description").Value
    DataPost.PublicationDate = CDate(post.Element("pubDate").Value)
    DataPost.Title = post.Element("title").Value
    dc.PostItems.Add(DataPost)
Next

Once the records are added to the table, we can commit them to the database with a single call to SubmitChanges as follows:

dc.SubmitChanges()

Ok, so that is easy enough. There are a couple of things to mention before we continue on. The .Add method will be changed to .InsertOnSubmit when LINQ and the .NET 3.5 Framework is released. This will be a breaking change for anyone who is currently working with the beta builds.

Another item of note: this implementation does not bother importing the various sub-collections, including attachments, comments, categories, etc. We will address some of those in a future update.

In looking back at the code and being more familiar with LINQ, it is about time to update this code taking advantage of some of LINQ's more interesting features. First VB 9 allows us to eliminate some of the functional construction syntax. Instead of weakly accessing the post.Element("description").Value, we can refer to post.<description>.Value. If we import the namespace, we will even get intellisense on the xml document.

In addition, rather than iterating over the item elements explicitly, we can use a LINQ query to create an IEnumerable(Of PostItem) list using the object initializers in the select projection. We then fill the entire collection using the table's AddAll (changing to InsertAllOnSubmit with RTM). With this change, we eliminate the entire for each loop. Below is the revised code:

Dim Feed As System.Xml.Linq.XDocument = XDocument.Load("http://devauthority.com/blogs/jwooley/rss.aspx")

Dim dc As New LinqBlogDataContext()

dc.PostItems.AddAll(From post In Feed...<item> _
    Select New PostItem With { _
    .Author = "Jim Wooley", _
    .Description = post.<description>.Value, _
    .PublicationDate = CDate(post.<pubDate>.Value), _
    .Title = post.<title>.Value})

dc.SubmitChanges()

That's it. We've read the feed from the site, filled the object collection and saved the resulting objects to the database. Clean and simple.

But hold on... The title of this post refers to the System.ServiceModel.Syndication.SundicationFeed object. This is a new object as part of the WCF enhancements in the .NET 3.5 Framework. To use it, add a reference to the System.ServiceModel.Web library. This object lets you create and consume feeds in both RSS and ATOM formats and use a single object model against both options. It also gives easy access to a number of child object structures, including Authors, Categories, Contributors, and Links. Additionally it strongly types the results so that we don't need to explicitly cast the values ourselves (for example with the PublicationDate). Here is the complete code to load the feed using the SyndicationFeed.Load method, fill the PostItem collection and submit them to the database.

Dim feed As SyndicationFeed = SyndicationFeed.Load(New System.Uri("http://devauthority.com/blogs/jwooley/rss.aspx"))

Dim dc As New LinqBlogDataContext()

dc.PostItems.AddAll(From p In feed.Items _
    Select New PostItem With _
    {.Author = If(p.Authors.Count > 0, p.Authors(0).Name, "Jim Wooley"), _
    .Description = p.Summary.Text, _
    .PublicationDate = p.PublishDate, _
    .Title = p.Title.Text})

dc.SubmitChanges()

The code is substantially the same as the revised version using the XML Literals above. The advantage of using the Syndication services implementation is that it abstracts the feed structure (RSS/ATOM), giving direct and strongly typed access to the contents.

Now that we've set this up, maybe I can work on using the SyndicationFeed to generate the feeds in ThinqLinq and present that in a future post. Stay tuned.

Technorati tags: linq, orcas, vb, xml

Code Snippets and Partial Methods

jwooley — Tue, 09 Oct 2007 01:59:00 GMT

In my VB 9 language enhancements talks, I do them withalmost all coding on the fly as I find people often can comprehend the code. I start by building a quick class that is used throughout the demos. To assist, I do use the snippet functionality in VB. For example, if you type "property" and then tab twice, the designer will generate a private field with public property accessors. The if you change the highlighted values, any associated names will be changed as well.

Private newPropertyValue As String
Public Property NewProperty() As String
    Get
        Return newPropertyValue
    End Get
    Set(ByVal value As String)
        newPropertyValue = value
    End Set
End Property

Personally, if you are not doing anything within your properties, there isn't much that you buy in using properties as compared to just exposing the field publically. I want a bit more functionality built into my properties. In the very least, I want to be able to include some change tracking. Once nice feature of the snippets is the fact that they are quite easy to modify and create your own.

To begin, we need to find where the supplied snippets are located on your disk. We can find this by clicking "Tools" and then the "Code Snippets Manager". We can find the location by drilling into the "Code Patterns" then "Properties, Procedures, Events" and find the "Define a Property" snippet. The location window will show you where this one is located. In the default install, it will be in your c:\Program Files\Microsoft Visual Studio 9.0\Vb\Snippets\1033\common code patterns\properties and procedures\ folder. Navigate to this folder and copy the DefineAProperty.snippet. Paste it as a new file and name it whatever you want keeping the .snippet extension.

The snippet file is just a XML document. Open it with visual studio to edit it. The top is a Header which includes the description information that will show up in the snippet manager. One change you will need to make is to alter the "Shortcut" tag so that it will use the key combination you want to use to invoke your custom snippet. In my demos, I use "propertycc", thus I change the header as follows:

<Title>Define a Property with PropertyChanging</Title>
<Author>Jim Wooley</Author>
<Description>Defines a Property with a backing field.</Description>
<Shortcut>Propertycc</Shortcut>

The key is to change the info in the Snippet node. In my case, I like to use a convention where the private field is the same name as the public property with the exception that it is prepended by the underscore. Thus, my field may be called _Foo and the property is called Foo. Due to this, I can eliminate the PrivateVariable node and just keep the PropertyName and PropertyType nodes.

With these changes in place, we can actually define our new generated code. This can be found in the CDATA section in the Code node. I use the following in my snippet declaration:

<![CDATA[Private _$PropertyName$ As $PropertyType$
Public Property $PropertyName$() As $PropertyType$
    Get
        Return _$PropertyName$
    End Get
    Set(ByVal value As $PropertyType$)
        If Not _$PropertyName$.Equals(value) Then
            _$PropertyName$ = value
            OnPropertyChanged("$PropertyName$")
        End If
    End Set
End Property]]>

With this definition, any time we change the starting PropertyName, all associated values will be changed for each snippet. When we save our changed snippet and open a class libarry, we can start to use our new snippet by typing "propertycc" and the following code will be generated for us:

Private _NewProperty As String
Public Property NewProperty() As String
    Get
        Return _NewProperty
    End Get
    Set(ByVal value As String)
        If Not _NewProperty.Equals(value) Then
            _NewProperty = value
            OnPropertyChanged("NewProperty")
        End If
    End Set
End Property

Now our property has a detection as values change and we can then do something with it. In this case, we will call an OnPropertyChanged(propertyName as string) method, assuming we have defined one in our class. If we don't have one defined, we won't be able to compile our application. We have several options to provide the OnPropertyChanged method. The class could inherit from a base class implementtation. The additional complexity level may not necessary in many cases. Additionally, we could implement a concrete method in our class. This will mean a slight performance hit if we don't actually do anything in the method.

As an alternative, we can use the new partial methods in VS 2008. The great thing about partial methods is that if they are not implemented they are compiled away. Additionally, we can place the partial stub in a partial class for generated code and then put the implementing method in the other half of a partial class which is isolated to the custom business functionality. With this architecture in mind, we can define our partial method in the class with the rest of our generated code properties:

Partial Private Sub OnPropertyChanged(ByVal propertyName As String)

End Sub

In the other half of our partial class pair of files, we can implement the method as follows:

Private Sub OnPropertyChanged(ByVal propertyName As String)

RaiseEvent PropertyChanged(Me, New System.ComponentModel.PropertyChangedEventArgs(propertyName))

End Sub

Public Event PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs) Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

If we don't need the implementation, the OnPropertyChanged method call in the property setters will be compiled away, otherwise we already have the stubs in place with our snippet in order to handle the functionality as necessary.

If you are interested in trying out this snippet, I'm attaching it to this post. Simply unzip it to your snippets directory and try it out.

Technorati tags: orcas,vb

Code Camp 2007 downloads

jwooley — Tue, 09 Oct 2007 01:22:00 GMT

I've uploaded the files for my presentations for the fall Code camp season which I just presented last weekend at the Birmingham, Alabama code camp. If you missed the talks, you can pick up the downloads at the following links. Also, I will be at the Charleston, South Carolina code camp this coming weekend (10/13) so you can catch me there. Additionally, the ThinqLinq talk is still available on the aspnetpodcasts.com. Links to all three parts of thie webcasts are available at http://devauthority.com/blogs/jwooley/archive/2007/07/27/66845.aspx.

Below are the links to each of the downloads for my three talks.

These and all of my demos are available via my downloads page at http://devauthority.com/files/13/jwooley/default.aspx?ppage=1. Don't let the license notice keep you from downloading the samples. It is just a boilerplate message that I'm not able to change at this point.

Technorati tags: linq, orcas,vb

Atlanta MS Pros/Cutting Edge/VB Study group

jwooley — Fri, 28 Sep 2007 17:22:00 GMT

Please join us on Monday, October 1 at 6:30 PM for the monthly Atlanta Cutting Edge .NET / MsPros / VB Study Group meeting.

Note, for this meeting we will be meeting at Turner in midtown (1015 Techwood Drive) rather than the usual Microsoft offices. If you haven't attended meetings in the past due to location, here's your chance to let us know if this facility is better. Scroll to the bottom of this message for directions to the meeting.

To register for this event, please go to http://www.clicktoattend.com/?id=121536. Registration for this meeting is required in order to get you through Turner's security.

Presentation Topics

Speaker: Steve Porter
Topic: Windows Workflow Rules Engine
Summary: This talk explores creating, maintaining and executing business rules using the Windows Workflow (WF) rules engine.

Speaker: Rik Robinson
Topic: Deep Dive CSS for the ASP.NET Developer

This will be a thorough discussion of all that is CSS. Whether you know it as the necessary evil or the great enabler (that just hasn’t quite clicked for you yet), you should walk away with something valuable from this discussion. I will begin with the basic box model and travel all the way to the holiest of grails (the no tables here, two and three column ASP.NET Master Page layout…yours to take home for free!). Along the way, we’ll touch on some CSS Best Practices and gotchas in ASP.NET and take a look at the new CSS tools in Visual Studio 2008 (Orcas).
Rik Robinson is an Independent Consultant in the Atlanta GA area. He holds the following certifications (all .NET Framework 2.0): MCPD –Enterprise Applications, MCTS-Web, MCTS-Windows, MCTS-Distributed Applications. He really hates that he has to type this in third person like someone else wrote it. Rik is supposed to maintain his blog at www.r2musings.com. He will soon, I’m sure. Rik’s focus is always on the User Experience (both the end user’s and the developer’s).

NOTE: Different location! We will be meeting at the Turner Broadcasting in Atlanta

Directions to Techwood

Marta Rail System: Midtown Stop on the North/South Line

FROM I-75/I-85 NORTH HEADING NORTH

Travel North on I-75 and I-85.

Take 10^th Street/14^th Street/Techwood Drive/Georgia Tech exit (Exit #250)

Turn left at first red light, onto Tenth Street (heading West)

Turn right onto Techwood Drive and left into the visitor entrance.

Pull up to window of the GateHouse and Security Officers will direct you to visitor parking

Take the parking deck elevator to the 1^st floor of the 1000 Bldg and check in with the receptionist in the lobby. Tell them you are with the Atlanta MS Pros.

FROM I-75/I-85 SOUTH HEADING SOUTH

Travel South on I-75 or I-85.

Take Techwood Drive/Tenth Street/Fourteenth Street exit (Exit #84)

Go straight ahead and the exit ramp turns into Techwood Drive

Cross 14^th Street and stay in the right lane.

Turn right into the visitor entrance on Techwood Drive

Pull up to window of the GateHouse and Security Officers will direct you to visitor parking

Take the parking deck elevator to the 1^st floor of the 1000 Bldg and check in with the receptionist in the lobby. Tell them you are with the Atlanta MS Pros.

Thanks, and I hope to see everyone at this month's meeting!

Nerd score

jwooley — Wed, 12 Sep 2007 17:28:00 GMT

My wife says I'm a nerd, but didn't think it was too bad. Seeing Shawn post his nerd score, I figured I would check it out and see. Little did I realize that I would score HIGHER than him in terms of technology. He got a much higher nerd score though.