Atlanta .NET Regular Guys

Atlanta MS Pros - Migrating from Linq to SQL to the Entity Framework, according to Jim Wooley

Last night we had about 60 people at the Atlanta MS Pros user group listening to Jim Wooley talk about the migration path developers currently using Linq to SQL might use to move to the Entity Framework.  Jim has some deep history with Ling, including being the coauthor of the Manning Press book Linq in Action. 

After the informative meeting, nearly 20 of us wandered over to the local Miller’s Ale House to continue our socializing over beer and enormous mounds of the Ale House’s famous Chicken Nacho’s

Don Browning shows Visual Studio 2010 to the Atlanta Microsoft Professionals

Don Browning from Turner Broadcasting came out of the fun buildings which bring you the Cartoon Network (and those other channels) to talk to the group about the new architecture features of Visual Studio 2010.  Those changes include:

• 6 new designers
  • case model – a visual view of user stories (including dependencies) backed to TFS (2008 or 2010) work items
  • class diagram – UML class designer NOT tied to code so you can make changes without messing up code
  • activity diagram – looks like a flowchart to show logic
  • sequence diagram – across a given span of time, what objects get used or come into play
  • component diagram – helps you define service interactions
  • Layer diagram
• architect explorer – architectural view of code supporting class view and solution view
• model explorer – model elements that are reusable are listed in the model explorer, which is a repository model of elements
• code analysis visualizations – a static analysis turned graphical including graph mode, force directed mode, and matrix mode.
• Integration with TFS – supports the storage of model elements in TFS and can be tied to work items.

The talk was clearly popular as we had a huge turnout at about 65 people!

Paul Wilson presents at the Atlanta Cutting Edge.Net

Paul Wilson, creator of the popular Wilson OR-Mapper, presented on the Provider Model and custom providers.  It was great to see Paul again, and I'm glad I got to see this presentation since I was unable to attend the first time he presented at the 2nd Annual Atlanta Code Camp.

<plug>
3rd Annual Atlanta Code Camp coming January 20th

</plug>

 Anyway, Paul gave an excellent presentation on custom providers, how useful they can be, and how easy they can be to create.  The basic premise was that while you have the ability to override a million and one different methods, you really only need to override and use a subset.  His code is online at his blog.  Oh, the other cool thing was that Paul came packing a dozen or so great books AND a super steller give-away!

Jim Wooley searches for the missing LINQ

 Jim Wooley, leader of the Atlanta Visual Basic Study Group, presented to the Atlanta C# User Group last night.  Or should I say that he presented to the newly re-branded Atlanta Cutting Edge User Group last night?  Either way, Jim Wooley presented his patented “Missing Linq” presentation to the group.  This is Jim’s third or fourth time presenting this particular topic, which has been on tour to regional code camps, and his familiarity with the material showed through in his insightful and well thought-out slide deck and accompanying demos.  This was my first time seeing this material as I missed the Atlanta Code Camp and have been too lame to make it to any of the other region’s code camps like the upcoming camp in Greenville SC (next week!!!). 

What can I say about the content of the presentation?  LINQ (Language Integrated Query) is a new “unified” programming model which is designed to let developers work with different types of data (relational = SQL = ADO, hierarchical = XML = XML/XPath, and object based = custom) using the same type of syntax.  There seem to be two major goals behind this initiative.  First – the syntax for todays coding is pretty domain specific and not very declaritive in nature.  It’s not always easy to tell what kind of data you’re working with.  I’ve stolen a screenshot from Jim’s slide deck here:

Using the new syntax provided by the LINQ implementations, you can take the above code (in screenshot) and re-do it so that you have this style code (stolen from demo code):

This is much nicer b/c you can see the elements in a declaritive fashion – you can tell what the XML document contains without having to read through the CRUD of constructing an XML document.  VB is even easier to read:

       Dim val = <XLinqRocksBecause version=<%= CodeCamp %>>
                      <LinqEssentials>
                          <Category>LINQ</Category>
                          <Category>DLINQ</Category>
                          <Category>XLINQ</Category>
                      </LinqEssentials>
                      <LanguageFeatures forDate=<%= Today() %>>
                          <release version="2.0">
                              <feature>Generics</feature>
                              <feature>Iterators</feature>
                              <feature>Anonymous Delegates</feature>
                              <feature>Nullable Types</feature>
                          </release>
                          <release version="3.0">
                              <feature>Implicit Types</feature>
                              <feature>Extension methods</feature>
                              <feature>Lambda Expressions</feature>
                              <feature>Object initializers</feature>
                              <feature>Anonymous Types</feature>
                              <feature>Expression Trees</feature>
                          </release>
                          <release version="9.0">
                              <feature>dynamic interfaces</feature>
                              <feature>dynamic identifiers</feature>
                              <feature>XML Literals</feature>
                          </release>
                      </LanguageFeatures>
                  </XLinqRocksBecause>

The second major goal of the LINQ initiative is to give developers a unified way to query into these different types of structured data.  This is accomplished with a set of extension methods that give the developer a very SQL type of language syntax for queries.  Here is an example query.

            var results = from f in new DirectoryInfo(@"C:\windows").GetFiles()
                          where f.extension == ".exe"
                          select new{f.Name, f.LastAccessTime};
Notice the semicolon – that’s C# code right there.  Extremely readable!  LINQ offers the ability to join in multiple data sources, change the sort criteria (orderby) and change the output values (including aggregations and calculations).  This query syntax will work with SQL data, flat file data, file system object data (as above), XML data, and more. 

Jim’s presentation was excellent and he’s going to present it a few more times at various user groups and code camps.  Keep up with his blog to learn more.  Five stars!

Last week's C# UG year end wrap up

Looks like I forgot to blog my impressions of last week's C# User Group's 2005 year end wrap-up.

The meeting began with a presentation on the Windows Communication Foundation (which used to be called Indigo) by Luthor Stanton.  Luthor gave us a sort of WCF 101 which seemed well received by the audience of about 32 people

Getting down to the business of the future of the group, the audience reaffirmed the group's committment to advanced programming topics.  In fact, the group may be straying away from C# language technologies and focusing more on advanced topics which are language agnostic (all presentations require C# code in a nod to the group's name).  There is also talk of one or more UG projects coming up.  The first project will be to replace the website (which is almost entirely static content that has to be hand modified) with a real, working ASP.Net application.  There needs to be some work done on the mailing list as well.

The general concensus of the group was that as long as we stuck with advanced topics and kept the caliber of the presentations as high as they typically have been, there might not be much that can be changed.  Some people voiced opinions that they'd like to let the main presenter have more time with their presentations, but Keith correctly pointed out that when a presenter starts earlier than 7pm, people get upset about arriving late.  That is why we generally have 2 presentations, a short one first, followed by an hour and a half long presentation at 7.

Keith is always looking for topic ideas and presenters, so please send him an e-mail if you're interested: http://www.atlantacsharp.org

-- Matt Ranlett

PS - I almost forgot to thank Keith here.  Keith took over the group this year in the late spring and was instrumental in growing the group from an average attendance of 5 people to an average attendance of 30 people.  Keith single-handedly wrangles all of the details of each meeting, needing almost no help at all from Brendon and myself or even Doug Turnure.  Keith's done a great job turning this group around and making it into a training experience that dedicated developers truely shouldn't miss.  Congrats Keith!

It has been a busy week

Las Monday was the C# User Group.  32 people showed up to hear Dan Attis present CodeRush and Mitch Harpur present Custom Remoting Contexts.  Both did a great job and were very informative.  One of these days, Dan will get through all the features of CodeRush in a 30 minute demo!  Mitch always does a great job and has some awesome technical content in his presentations.

Last Friday I got together with some friends and we watched Zathura - the new movie from the same folks who did Jumanji.  The movie was a lot of fun to watch - possibly more so than Jumanji itself.  Very neat effects.  Not a whole lot of plot here, but the movie was highly entertaining.

Last Sunday a friend of mine in the UK, Phill Bowden, helped deliver his first-born son - Augustine Aldhelm Hiroshi.  Congratulations Phill!

-- Matt Ranlett

C# UG meeting - August 1, 2005

I’m way late posting anything about the C# UG meeting, so I’m not going to restate what others have said for me.  Check out the following links:

Keith Rome – C# UG Leader

Chris Wallace – our technical presenter

Eric Marvets – our feature presenter

— Matt Ranlett