Atlanta .NET Regular Guys

Atlanta Mobility UG meeting cancelled for Monday, July 18

7/13/2005 10:08:40 PM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, July 20^th, Randy Miller from Microsoft’s Visual Studio 2005 Team Systems group is coming to the Microsoft Offices to talk to the SPIN process User Group about the newest features of Visual Studio Team Systems and MSF Agile. For more information, visit www.atlantaspin.org. To prevent us from having three User Group meetings in a single week, we have elected to cancel the Monday meeting of the Atlanta Mobility User Group.

-- Matt Ranlett

posted with BlogJet

.NET Community | .NET Events | Mobility User Group | User Groups

7/13/2005 9:45:32 PM (Eastern Standard Time, UTC-05:00)

Trackback

SQL Server group moved to Thursday, July 21

Bill Baker, program manager of the SQL Server Business Intelligence team, is coming to town on July 21^st to speak to the SQL Server User Group. To accommodate Mr. Baker’s busy schedule, the SQL Server group will be meeting in the Microsoft Offices off of Mansell Rd instead of their normal meeting location in the Concourse buildings. Be sure to visit www.atlantamdf.com to register for the meeting. Registration is used to calculate how much pizza should be purchased.

-- Matt Ranlett

posted with BlogJet

.NET Community | .NET Events | SQL Server USer Group | User Groups

7/13/2005 9:44:07 PM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, July 08, 2005

Atlanta Visual Basic Users Group - 29 June 2005

Sandy Roach began the group meeting with a presentation of delegates and event handling. Sandy tried to show us some simple examples of delegates in Visual Basic – including a sample which uses delegates to invoke a class’s instance and shared (static) methods. Sandy also covered multicast delegates, which invoke multiple methods from a single call. The power of delegates is that you can write code to call a single method, and then use delegates to have that one method call actually make calls to multiple methods.

Reading that sentence, it seems unclear. So let’s try it with an example. Suppose we have a program which deals with books. We have two significant functions: PrintTitle and Totalizer. If we create a delegate for each of those two functions, we can pass the pointer to the functions into a method call: ProcessBooks. ProcessBooks with then either print the title of the book or perform the logic in the totalizer function, depending on which delegate was passed to it. Notice that these two functions do nothing like each other – one handles strings and the other handles numbers. The fact that the delegates for both have the same signature (number of parameters) means that you can use either delegate from the same method call. Check back with the original post I wrote covering D’s presentation on delegates to the Mobility User Group.

— Matt Ranlett

posted with BlogJet

Atlanta .Net User Group and the Enterprise Library - June 27th, 2005

7/8/2005 1:33:40 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, June 28, 2005

Top announcement of the day: the mini Code Camp in Charlotte on August 20th. Brendon and I are already registered. Keep an eye on Maxim’s blog at www.ipattern.com for more details as they become available.

In other news, we had four companies looking to hire developers, including Magenic and Avanade. This does not include the recruiter who showed up for the first part of the evening.

After a bit of fun with the projectors and laptops, the presentations got underway. Doug Turnure filled in for Marty Mathis (unable to make it) and gave a brief look into how Reflection can expose your innermost private values. Just to review, reflection works by reading the .Net metadata to dynamically discover methods and fields. Doug began the presentation with a simple base class that he used as the object of reflection:

public class Customer
{
public string FirstName;
public string LastName;
private string Secret

public Customer(string firstname, string lastname)
{
FirstName = firstname;
LastName = lastname;
Secret = "SerenityNow";

public void Buy()
{
Console.WriteLine(me.FirstName + " is buying something");
}

private void SecretBuy()
{
Console.WriteLine(me.FirstName + " is secretly buying something");
}
}
}

Then we took a tour through reflection with the following code (I’m not bothering to write everything out)

using System.Reflection

Customer c = new Customer("Doug", "Turnure");
Type t = c.GetType();

foreach(MethodInfo mi in t.GetMethods())
{
// write out all the public method names
Console.WriteLine(mi.Name);

// invoke the Buy method
if(mi.Name = "Buy")
  mi.Invoke(c, null);
}

// use the binding flags to specify which types of methods and fields to reflect on
BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHeirarchy

// show all methods
foreach(MethodInfo mi in t.GetMethods(bf))
{
// write out all the method names
Console.WriteLine(mi.Name);

// invoke the private SecretBuy method
if(mi.Name = "SecretBuy")
  mi.Invoke(c, null);
}

// this can be done to fields as well - even allowing changes to fields
foreach(FieldInfo fi in t.GetMethods(bf))
{
// write out all the field names
Console.WriteLine(fi.Name);

// change the value of the private field Password
if(fi.Name = "Password")
  fi.SetValue(c, "New Password"); //this will also overwrite readonly data
}

The reason this scary stuff works is because the runtime needs to know about your code, so everything is exposed. The only way to prevent someone from hacking your assembly is not to give it to them. Use web services. Or partially trusted permissions.

Doug finished his presentation and received polite applause as most people in the room looked around at each other in shock that their private data wasn’t actually private. Similar to the SPIDynamics presentation on SQL Injection and cross site scripting – there were several panicky looks…

Up next after Don was Steven Tynes from Avanade to present the Enterprise Library. For those who don’t know, Avanade is a joint venture between Accenture and Microsoft. They’re looking for bright people, so if you want a traveling job….

The Enterprise Library is the next logical growth after patterns (atomic solutions to common programming problems) and application blocks (subsystem level guidance for common services). The Enterprise Library helps to make the app blocks more consistent, easier to configure, and work together better than they did previously. Entlib is actually part of the patterns and practices guidance library and is a growth from Avanade’s original Application Connected Architecture for .Net (ACA.Net). The entlib is entirely free and is used as part of the framework for hundreds of software projects. Avanade has actually integrated the Enterprise Library into their new version of ACA.Net and is using it in over 30 clients’ projects.

We listened to Steven talk about the entlib configuration tool and the Data Access block for the majority of the time. There were so many questions from the group that the presentation quickly and frequently wandered away from the core material. Rather than try to cover what actually was said (the continuous questions were so distracting I stopped paying attention), I’m going to paste in a review of the Entlib I wrote several weeks ago when I saw Richard Weeks from Avanade presents the Enterprise Library:

The Enterprise Library wraps several of the PAP application blocks (Data, Config, Crypto, Security, Exception, Logging, etc). The goal of the enterprise library is to simplify the use of these blocks. For example, the extremely slick Configuration tool (add to the Tools menu by customizing the menu) will create all the XML in the App.config file based on a user friendly GUI as opposed to writing the XML on hand. The Database block allows you to connect to a DB, execute a stored proc, and bind the results to a grid in three lines of code. The logging component makes logging so easy it’s almost hard to believe. One line of code – Logger.Write(“text here”) – that’s it! Based on the config, we were logging to two places at the same time with independently configurable levels of detail. The exception component allows “exception policies” to be defined and log, wrapping an exception with another exception, replacing an exception with another, or create your own action. The exception policy tool was really sweet – complete with a list of potential exceptions (reflection, anyone?) you can select from. Dan and I both enjoyed this presentation – it looks like something really useful.

— Matt Ranlett

posted with BlogJet

Visual Basic.Net UG - the architecture series. May 31, 2005

6/28/2005 2:32:50 PM (Eastern Standard Time, UTC-05:00)

Trackback

Thursday, June 02, 2005

Jim Wooley and I showed the group a little higher level material this time. Jim showed off Generics, using the WhiteHorse class designer and separate code implementations contrasting inheritance, interfaces, and generics. Using simple examples he showed us how generics preserve Intellisense and provide faster runtimes over 100,000 iterations. Despite being a contrived example, we saw clear differences in performance over significant numbers of element access.

I showed off the Observer pattern using the example provided by the Head First Design Patterns book (this went on the white board) and an article from OnDotNet where a reproduction of a binary clock sorta demonstrates the concepts of an observer pattern. The thing I learned most from my own presentation is that I need to spend more time reading that Head First Design Patterns book. I felt like I understood what I read, but I had a hard time explaining it in a way that made sense to everyone else. Actually, I had a hard time explaining the example they used in the book to illustrate the bad way to do things. Everyone got the correct “pattern” method right away.

— Matt Ranlett

posted with BlogJet

Mark your calendars! Bill Baker is coming to town...

6/2/2005 1:36:16 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, May 31, 2005

Bill Baker, the general manager for SQL Server Business Intelligence with Microsoft is coming to present to the SQL Server User Group. To accomodate Bill's busy schedule, the SQL Server group will be meeting in the Microsoft Offices in Alpharetta on Thursday, July 21st. The doors open at 6:30 and Microsoft will be providing some refreshments.

Come one, come all, learn the magic that is BI. Be sure to register at the SQL Server group website

-- Matt Ranlett

Microsoft Products | SQL Server USer Group | User Groups

5/31/2005 11:16:20 AM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, May 18, 2005

David Chappell makes a splash in Atlanta with the Indigo Roadshow

Richard Conn introduced the Academic Relations Program – where Microsoft attempts to establish a relationship with various universities around the country. Pretty much what this means is discounted Visual Studio and Office licenses for universities and university students. Microsoft has even started to reach into the high schools, with 20 high schools in Atlanta alone participating. If you have a high school student or college student interested in the computer sciences, Microsoft offers some excellent internships and scholarships. Another interesting facet of the ARM program is its tie to Microsoft Research and a curriculum available to all for teaching Microsoft technologies.

David Chappell introduced himself by making sure that everyone knew he isn’t Dave Chappelle. Nor is he Dave Chappell from Sonic Software (who ironically also writes books and give technical presentations on enterprise messaging). After some fun at his own expense, David jumped into his presentation by postulating that there is always some kind of application architecture for enterprise systems. This started with mainframes, moved on to client/server systems, and then on to multi-tiered architectures. We may now be on the verge of shifting into the fourth evolution of enterprise systems, service-oriented architecture. The reason this shift is possible now and not before is due to the global vendor agreement on how to consume web services. Service-oriented business logic needs to rest on a foundation that is standard and ubiquitous. On Windows, this platform will be Indigo.

In the simplest sense, Indigo is a bunch of C# classes that extend the .Net framework with a new namespace. Indigo communicates through SOAP messages, functioning as an über SOAP stack. This unifies existing MS technologies (ASMX, .NET Remoting, Enterprise Services, WSE, MSMQ) for distributed applications. It also provides interoperability between .Net apps and others (EJB and WebSphere). Finally, Indigo offers the idea of explicitly building service oriented applications.

An important note is that Indigo is not backwards compatible with existing .Net distributed technologies. . Indigo actually implements much of the functionality of the existing technologies, including SOAP over networking channels and many of the WS-* standards. Once Indigo is release, Microsoft will no longer be enhancing the existing technologies. Indigo will not replace the existing technologies, and will not prevent those technologies from working.

Service-Oriented Applications are generally abstracted into Data (relations), Logic (objects), and Presentation (GUIs). Indigo fits into this picture between the logic and presentation and can be thought of as Access to Services. In the past, the link between Data and Logic has been the mapping of tables to object hierarchies and of SQL types to Java/CLR types. When the object-oriented Religion hit the world, OODBMS systems hit the market, only to fail. It turns out that mapping between the relations and objects is easier. Similarly, when the object religion hit the relationship between Logic and Presentation, Microsoft introduce a way to expose object interfaces –> COM and DCOM. That turned out to be very painful. Indigo goes back to the concept of mapping between services.

Having covered the basics of Indigo’s intentions, we now looked at code.

To create an Indigo service, you must implement a service class – the methods the services provides. You must select a host – the app domain and process the service runs in. Finally you must specify one or more endpoints in which to access the services. You have 2 methods for implementing a service class – mark a class with the ServiceContract attribute. Or mark an interface with the ServiceContract attribute then create a class that implements the interface. A caution – Indigo attributes (OperationContract) and C# modifiers (public, private) are completely separate – you can tag a private method with an OperationContract, thus exposing it to applications OUTSIDE the AppDomain. However, that same method is private within the application. David tried to convince us that this is actually a good idea by explaining that you can create a facade of classes which invoke internal methods and expose their methods as services. However, the facade of classes are not supposed to be called from within the application. The group seemed leery of this – much grumbling about a new “method type” was heard. My personal impression is that this seems to be an attempt to encourage good design (i.e. – the Facade pattern) on future projects.

Additional options in Indigo development: One way calls adds a modifier to the OperationContract (IsOneWay=true) for events. Duplex contracts for both the client and service invoking operations in the other. Message contracts allow working directly with the SOAP messages. all data sent and received by operations must be serialized and de-serialized. The way that they are serialized is based on the data contract. To create and pass your own types or enums, you must define a data contract (more attributes).

A quick aside: SVCUTIL can be used to generate a skeleton service class from WSDL contracts if you want to design your interface contracts before writing code, or contract first development. By contrast, writing the code first and adding the ServiceContract and OperationContract attributes as needed is called code first development.

When defining a host, you can host a service in an arbitrary process (exe, NT service and winform/avalon processes) or host a service in IIS or the Windows Activation Service (WAS) – a lite webhost for machines not running IIS. An app or service would use the ServiceHost generic type. IIS/WAS require virtual directories and a .svc file. Just like ASMX, an instance of the service class will be created when a client request arrives.

Finally, you must specify an endpoint – every client connects to a specific endpoint. Every endpoint has 3 things: an address (where to find it), a binding (how to communicate), and a contract (what can it do). Addresses are usually URIs. Bindings wrap together may aspects of communication such as protocols for conveying SOAP messages (HTTP, TCP, etc) security options, support for wS-* specs, and more. Several predefined bindings will ship with Indigo but custom bindings can be created. An example of a predefined binding is BasicProfileBinding which conforms to WS-I Basic Profile 1.0. WS ProfileBinding supports WS-ReliableMessaging, WS-Security, WS-AtomicTransaction, and other WS-* specs. NetProfileTCPBinding sends binary encoded SOAP with support for reliable messaging, security, and transactions directly over TCP (Indigo to Indigo only). One service can expose separate endpoints, each with a different binding for different clients. Contracts are the name of the class that the endpoint exposes (service class or interface). Endpoints are likely to be defined in config files, but they can also be added directly within the code assembly.

To create an Indigo client, create a channel to a service (typically hidden by a proxy which has been created by SVCUTIL or Visual Studio). Clients also specify a specific endpoint that they will communicate with. That’s about it – nothing very complex.

Services built on Indigo can be reliable, secure, transactional, and queued. Indigo also offers reliable messaging; raw SOAP doesn’t guarantee reliable message transfer but some of the Indigo bindings such as WsHttpBinding, support WS-ReliableMessaging. However, WS-ReliableMessaging doesn’t directly support message queuing – this is still an area where the vendors can’t agree on a standard. Since that the world in general and Microsoft in particular has caught the Security Religion, Indigo allows for security configuration via authentication, message integrity, and message confidentiality. Indigo also uses the .Net security model and the PrinciplePermission concepts. Indigo transactions are built on the new 2.0 System.Transactions namespace. Now transactions are separate from state management (different from Enterprise Services, COM+, and MTS). Indigo apps can use System.Transactions explicitly or can use OperationBehavior attributes (which use System.Transactions under the covers). Indigo supports queuing by running on MSMQ as the transport. This means queuing only works on the Windows platform. There are predefined binding choices which wrap queuing.

When considering upgrading to Indigo services, keep in mind that all existing apps will continue to work. However, if you do decide to upgrade, keep in mind the following questions. Will my Indigo app and apps built with existing technologies be interoperable and will my apps be portable? The Indigo team says yes to both questions for ASMX. Remoting will not be interoperable. Enterprise Services interfaces can be wrapped with an Indigo-supplied tool. ES clients will communicate use an Indigo moniker. WSE 1.0 and 2.0 are not interoperable or portable. WSE 3.0 will be interoperable AND portable, but it hasn’t been released yet. MSMQ is interoperable using MsmqIntegrationBinding, but portability is not a simple task.

Indigo vs Biztalk. Indigo is a platform for building services on .Net. Biztalk is an integration tool which maps between various heterogeneous environments. Biztalk already has adapters for technologies like MSMQ and SQL. Expect an Indigo adapter in Biztalk soon.

There is a March CAP currently available for Indigo and we expect the Beta 1 of Indigo in a matter of weeks.

Questions from the audience included:

Indigo talks to a service, what do I get back, a Dataset? Actually you get XML (SOAP), but the data in the message is some kind of serialized object. So it could be Dataset or objects.

What about the rich type support of Remoting? Indigo can serialize any .Net type when talking to other Indigo services. However, when interacting with other environments, use contract first development to ensure data type interoperability

How will Indigo handle big objects like Datasets? Indigo serializes an object sent to it and drops it on the wire.

MSMQ has a max message size, how does Indigo use MSMQ to transmit larger objects? MSMQ is a transport mechanism like TCP – large files are broken up and sent across the wire in discrete chunks.

Does Indigo require full trust to run on a machine like .Net Remoting does? David Chappell wasn’t, but Doug Turnure doesn’t think so. Research is required.

Can you serialize custom types? Yes with a data contract. Alternatively you can drop in your own seralizer.

I ran across this link a while ago in my RSS aggregator and thought I’d post it here as it’s extremely pertinent: Don Box’s Five Minute Indigo Challenge.

— Matt Ranlett

posted with BlogJet

Microsoft Products | Programming | User Groups | VB.Net User Group

5/18/2005 11:46:16 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, May 17, 2005

The Mobility User Group learns about C# Delegates - 16 May 2005

Our own local Delta representative, Venkat Polisetti kicked the meeting off with a presentation about web services on the Compact Framework. To begin, we compared synchronous web calls to asynchronous web calls:

Synchronous calls to web services:

can be dangerous because they have the possibility to freeze your user interface until the call completes in the primary thread.
can be useful when the web method returns quickly and they are very easy to code.

Asynchronous calls are:

executed on a different thread
more complex to code but
won’t freeze your UI when the web methods are slow to respond.

Consuming a web services on the Compact Framework is pretty much the same as with web and winform apps. When a web reference is added to a project, VS.Net creates a proxy class in the project and creates Begin and End methods for asynchronous operations. Call the Begin method to initiate the web service call and call the End method to complete the web service call. Venkat had prepared a demo for us to help us understand the complexities of using web services and the Compact Framework but his demo misbehaved a bit; the group tried to help out but the problems were initially beyond us. So Venkat took a seat to work on his laptop and gave the floor to Dhamayanthi (D for short). We ran out of time, so Venkat will show off his demo at the next Mobility UG meeting (he did get things working before the end of D’s presentation)

D started her presentation with a quick recap of polymorphism and inheritance. The example she gave was to create a base class with multiple layers of inheritance – ProjectManager inherits from Employee which inherits from Person. She then posed a question to the group, “How do you create the correct object when you don’t know which type of object is required up-front?” The answer is to have the code look up the correct object type and then return to the calling function a reference of type MyAbstractBaseClass. The reference will point to the correctly created object type. This explanation of an Object Factory also encapsulates the concept of dynamic polymorphism. We had spiraled out to a discussion of the Abstract Factory design pattern before D reigned us in and brought us back to dynamic polymorphism with an explanation of how delegates help simplify function calls which have the same signature. She showed us how to use a delegate in C++ before showing us the differences in C#, making sure we all knew our roots.

A delegate in C# is an object-oriented, type safe function pointer. This complicated concept is easily explained by Chris Sell’s article, “.Net Delegates: A C# Bedtime Story”. The story tells of an employee with a mean boss. The employee writes code to notify his boss every time his status changes and the boss is happy. But the next day the boss’s boss wants to be notified of the employee’s status changes. This continues (adding bosses to the list) until the employee is forced to allow any interested party to subscribe to his status change events. To do this, the employee defines an interface that the various bosses will implement (thus inheriting from the employee’s class (Interface Inheritance)). Now anyone who implements the interface can pass their own objects into the interface methods as parameters. This demonstrates polymorphism b/c the functions don’t know ahead of time which objects (bosses) are going to ask for status updates but they are able to take any objects that implement the interface.

The next step in improving the code is to allow the boss objects to implement only the interface methods that they are interested in, not the ones they don’t care about. The other thing we can improve upon is not requiring the use of specific method names. Delegates are interfaces with one method which don’t require interface inheritance. This is good b/c in .Net we are only able to derive from a single base class. By taking each method in an interface and declaring them each as an individual delegate (essentially wrapping the method call in a delegate) the coupling is much looser – improving the flexibility of the code. Delegates are capable of wrapping both instance methods (created when you new up an object) and static methods (which don’t require the creation of an object).

A problem of delegates is that they are public methods and can be directly invoked (skipping the notification feature of the delegate). Another problem of delegates is that a delegate only returns to the last registrant. If multiple people register for the event and they don’t register for an event with +=, then they will erase all the other registrations. To prevent this, wrap the delegates in events. The framework will then create the register and unregister events. If someone then tries to use the event without using += syntax they get a compiler warning. D was on the ball tonight, even breaking out ILDASM to show us what was happening under the covers with delegates and events, and how += completed and -= completed are both overloaded in IL as add_completed and remove_completed (where completed is our delegate name).

The next problem we had to solve was how to get the return value of each delegate or event call when multiple objects (bosses) have registered. The answer is to use the event’s .GetInvocationList method and save the results in a delegate variable. Of course, we don’t want to do this synchronously – we need to make sure we can pass by registrants who aren’t ready to report their results. This is where the BeginInvoke method of a delegate comes into play – you can call the event’s BeginInvoke on the method without passing anything in or retrieving anything out. This is the Fire and Forget method of handling this problem. A better way to handle this problem is to use the IAsynchResult interface and the callback functionality (which takes advantage of the threadpool). The IAsynchResult interface exposes an IsCompleted method which can be used to poll a thread’s status. Once IsCompleted = TRUE, you can call the event’s EndInvoke method. However, EndInvoke is a blocking call so you don’t want to call it unless you’re sure that job is done. The most elegant method of handling the check of return results is to define an AsynchDelegate (type AsynchCallback) to do the checking for you.

A great question was asked by the group – what happens if the event you are calling on a different thread throws an exception? How do you inform your main thread? This question is left as an exercise for the reader! We didn’t have time in the group to really explore the issue.

Positive feedback all around – everyone though the topic was fantastic and that D was a great presenter. In fact, if she ever comes back to Atlanta, we’d love to have her back to present another topic. She told us she’s got a great presentation on design patterns. Maybe I’ll be able to get this presentation from her and let the group work with it on their own time.

Thank you to everyone who showed up and thank you to both Venkat and Dhamayanthi for presenting!

— Matt Ranlett

posted with BlogJet

C# User Group | Mobility User Group | User Groups

5/17/2005 12:08:22 PM (Eastern Standard Time, UTC-05:00)

Trackback

Announcements for May

What’s left in the month of May?

This Wednesday, the 18th – the VB Group is hosting David Chappell and the Indigo Roadshow in the Microsoft Offices. Show up early for guaranteed seating – space might be tight as there is HUGE interest in this topic. This is TOMORROW!
This Thursday, the 19th – MSDN Event with Glen Gordon at the Chamblee Regal Cinemas. Three great topics followed by a Pub Club. Show up to the MSDN event to learn the location of the Pub Club.
The .Net Book Club meeting is cancelled in favor of the MSDN Event and the Pub Club. We’ll pick up where we left off next month.
There are no other meetings this month – the main .Net UG is not meeting in May due to Memorial Day.

— Matt Ranlett

posted with BlogJet

User Group topics for future presentations

5/17/2005 11:11:11 AM (Eastern Standard Time, UTC-05:00)

Trackback

Michael Earls, Brendon Schwartz, and I went out for snacks and beer (mostly beer) after the Mobility UG tonight and sat there chatting until after midnight. While most of the talk hovered around career paths and war stories, one of the topics of conversation might be interesting to the rest of the Atlanta .Net User Group attending public. We were talking about what kinds of topics we wanted to see in the near future. We sat there brainstorming and blurting out ideas. I thought I'd list a few that we mentioned and then open the comments up to the general (blog-reading) public to see what interests the community at large.

Here are a few of the topic ideas we discussed:

Biztalk - Microsoft is on the verge of releasing Biztalk 2006. Do we all understand the value of Biztalk in general?
Sharepoint - this communication and collaboration tool has helped to shape ASP.Net (webparts)
Analysis Services - what good is having data in a database if you can't understand what it's telling you?
WMI scripting - system administrators understand the value of this tool. Do developers?
Typed Datasets verses Objects and abstracted data - an architectural decision you can't make until you understand both concepts

What technology topics (not just development topics) do you want to see? Do we want to get ever deeper into code like we have with the CLR team and our recent discussion in the Atlanta Mobility User Group about delegates or do we want to learn more about some of the tools that Microsoft is providing to make coding easier? Don't be silent - let your voice be heard! This is about all user groups in general and not a single user group specifically.

-- Matt Ranlett

SQL Server UG - 9 May 2005 - Reporting Services 2005

5/17/2005 12:20:43 AM (Eastern Standard Time, UTC-05:00)

Trackback

Monday, May 09, 2005

Thank you to Unisys and Melanie Marks for providing the pizza and prizes for the evening.

Doug kicked off the meeting with a quick demo of the DTS Integration Services Data Flow interface in the new 2005 Reporting Services Reports Builder UI (part of Whidbey’s 2005 Visual Studio interface). In Doug’s quick demo, he showed how easy it would be to take a flat file, pipe the input from the flat file to a pair of tables using Data Flow sources (flat file), transformations (to pipe the raw input to one table and the summarization of the raw input to another table), and destinations (database tables in this example). One of the really neat things about the demo was how the drag and drop tool turned from the design environment to a graphic representation of the progress of the DTS program in the debugger. During this quick preview of SSIS data integration, a question came up about the differences between SSIS and BizTalk. The results of the discussion were that BizTalk is assured delivery across a heterogeneous environment where SSIS is called integration services but usually functions as a data movement engine.

The main presentation was an introduction to SQL Server 2005’s Reporting Services Report Builder. The core changes to RS 2005 include some tighter integration with Sharepoint and the end to end BI. Rich Client printing has been added to RS. The Expression editor has been enhanced with VB.Net functions complete with Intellisense. Multi-Valued parameters have been added – the report processing will create SQL. the ASP.Net date picker has been included. Interactive sorting has been added so sorting can occur without requerying the data. Floating header (like Excel) so you don’t have to build paged tables with header rows. Custom report items allow the API to be exposed, so that 3rd party vendors can provide charts, maps, etc. Analysis Services support now integrates MDX parameter support and data mining query builders. Management Studio integration functions as a single point of management for all SQL Server components, a supersert of Report Manager functions. SharePoint Web Parts have been added – now you can integrate your reports into Sharepoint Services and Sharepoint portal server. Visual Studio’s integration is better. The Report Controls in Visual Studio make it easier to embed reporting functionality into applications (both web and winform).

The Report Builder fills the need between the report manger (for report consumers) and the report designer (for power users and developers). The business users would be using the report builder. Caution – report builder requires SQL Server Enterprise Edition. Report Builder is an ad-hoc report design tool for SQL Server RS. This is targeted at business users who want to find and share answers. This is not an analytical client or a replacement for pivot tables. Report builder doesn’t query SQL objects, but rather queries a semantic model of the data making is so that the business users don’t need to know SQL to write the reports. The report builder is a smart client application downloaded directly from the Report Manager web application. To build a report, you pick a template (chart, matrix, table) and drag table fields onto the design surface. When you build the report, you can page through the report and click on any detail to look in more detail (infinite drill).

Next we took a look at the semantic modeling tool. We used Visual Studio to build a report model for the Northwind database. You would use this to build a semantic model the business user would use to generate Report Builder reports. You start out with a Data Source View – use the wizard to create one if one’s not already been created to meet your needs. Once you have a data source view, the report modeling wizard makes some assumptions about the data (you can override these assumptions, but the wizard is pretty powerful) and generates a set of metadata in 2 passes. Once your model is completely processed and you have an SMDL (semantic model definition language) file, you can publish it to the reports server, or you can add expressions and calculations to the report model. Now that the SMDL file has been published, and you have your new report model, you can build new reports with the Report Builder tool.

My personal impression of the tool is this – this is a great tool which has great potential. I can easily see savvy business users creating their own reports to explore details that are smaller and less sophisticated than full RS or Analysis Services reports. I especially like the infinite drill capabilities and the ability to save any drilled down view to the report server as a stand-alone report. However, currently you can’t reverse-engineer the data connections of a report builder report in Visual Studio, so you’ll have a hard time taking a report builder report (also RDL like Visual Studio’s Report Designer’s reports) and turning them into true Report Designer reports (with true SQL as the data source, rather than the semantic model of the SQL objects). Another problem is the enterprise edition requirement – drastically increasing the price of the tool for small shops.

I asked a couple of people at the UG meeting what they thought of the presentation and our presenter. Based on the questions I heard from the group during the presentation, there seemed to be a good deal of excitement around the possibility of granting the users the ability to generate their own reports via infinite drill, but there seemed to be several questions concerning the underlying technology. I got the feeling that a lot of the developers/DBAs were uncomfortable with the semantic model’s removal of SQL – perhaps the feeling of a loss of control? Otherwise, people were very positive about both the presenter and presentation. Great job Doug!

— Matt Ranlett
posted with BlogJet

User Groups | SQL Server USer Group

5/9/2005 9:01:38 PM (Eastern Standard Time, UTC-05:00)

Trackback

Reminder - .Net Book Club meeting cancelled

This is just a reminder – the May 19th meeting of the .Net Book Club has been cancelled due to the MSDN Event and Pub Club. Be sure to sign up for the MSDN Event on www.microsoft.com/events!

The Pub Club will be held immediately after the MSDN Event at a nearby location, but you need to attend the MSDN Event or any user group between now and the 19th (the Mobility UG and the VB UG both have meetings scheduled)

— Matt Ranlett

posted with BlogJet

.Net Book Club | User Groups

5/9/2005 8:59:50 PM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, May 06, 2005

VB.Net Study Group May 4th, 2005

We had a few new faces at the VB.Net meeting tonight. After a bit of social chatting, Jim Wooley started the meeting with a presentation of the FileSystemWatcher done in VS2005 Beta 2. For the sake of simplicity, we went with a Windows Forms applications. Take a form, drop on a ListBox and a FileSystemWatcher control. A FileSystemWatcher component basically does what it sounds like – it watches the file system for some file and some event. You can filter by file type (ex. *.txt) and you can filter by event (changed, created, deleted, etc.). With this really simple demo, we were able to see that the operating system raising events to our code. Something we did notice is that the OS throws several events where we might only expect one event. For example, open Notepad, type some text, and save it into your monitored directory. You’ll see that you get CREATED, DELETED, CREATED, CHANGED, and CHANGED events. So you’ll want to do error handling to prevent yourself from acting on the wrong one of those events. Extremely simple, but a great demo to show how useful the FileSystemWatcher can be.

The next presenter was Harrell Perlman, showing us Avalon. If you plan on taking a look at Avalon, you need to have XP service pack 2. Longhorn’s betas are not supported yet. You’ll also need a beta copy of VS2005 to work with it. Harrell had a heck of a time getting his Virtual PC installed with the WinFX and Avalon, so he spent a good deal of time making sure that we’d understand the installation procedure. WinFX is an extension of the .Net Framework that is utilized by Avalon (meaning that Avalon runs entirely on managed code). Avalon uses XAML (a flavor of XML) to describe the layout and ties to code behind classes for event wiring. We’re really early in the Avalon lifecycle (still Alpha) but there are already a wealth of articles discussing Avalon concepts. Download the Avalon, WinFX, and (possibly) the LongHorn SDKs, install them in a Virtual PC or Virtual Machine, and go! We took a quick look at a demo or two to see what the XAML markup language looks like. The general reaction of the group was that we didn’t really know where we were going with XAML. To me personally, it looks like the ASP.Net seperation of the presentation layer and the UI Process Layer.

Dan Bredy was presenting an article from Mike Gold (VBHeaven.com), recreating the W2 tax form. The program uses GDI+ to render the content of some textboxes and place them directly onto an image of an actual W2 form. Basically, set the background of a form to an image. Place a bunch of textboxes and checkboxes on the form. Then use the DrawString function to render the text directly onto the image (you basically can’t see the textboxes). This takes place during the print preview portion of the application. This makes use of the System.Draw.Graphics namespace to render the image and to draw the text from the various textboxes onto the image based on the location of the actual control.

— Matt Ranlett

posted with BlogJet

The CLR team gives the C# User group a glimpse behind the curtain

5/6/2005 9:57:01 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, May 03, 2005

Kit George, Program Manager on the Common Language Runtime (CLR) team in charge of the base library, stood up as our first presenter. He jumped right in to some demos to show some v2 improvements. (All the demos are available on the Visual Component Library (VCL) website)

The first demo introduced us to some memory management (Garbage Collection) concerning unmanaged resources.
The second demo showed the improvement in performance between Try{Parse}Catch and TryParse.
The third app showed us how the VCL now supports the serial ports. It also showed us color in console applications and generic collections.

Brad Abrams, a founding member of the .Net Framework team, was here to present the deep internals of the CLR and basically show that he knew everything about CLR and compilers. He strongly warned us that his presentation was not going to cover knowledge required to be a programmer and that everything he showed us was going to change as the CLR evolved. After a rapid review of the process of creating an executable, we created a quick “Hello World” application and looked at the Intermediate Language (IL) code thanks to ILDASM. Looking at the IL we were able to see which version of the CLR the exe was compiled with, the assembly hash information, and the entrypoint information. We even saw that by modifying the IL entry point and recompiling via ILASM, the behavior of the program could be changed (not that there is ever any practical use for this information). We learned that .Net assemblies are made up of the Manifest (external data) and the compilable IL + it’s metadata and required resources. IL metadata is the actual language for execution. It is independent of the CPU and platform, making it capable of running as both 32 bit and 64 bit applications without change. IL is also a stack based language, meaning that every operation runs on a stack – pushing and popping variables. IL bakes type safety into the CLR through a process called verification. This helps prevent mixing incompatible types and bad array handling. Brad covered the startup logic, showing how the CLR uses mscoree.dll to check version numbers and run the correct CLR version, allowing multiple .Net frameworks to be on the same machine and code designed for each to run successfully. We looked at what happens in memory when an object is allocated and its methods are called. This included understanding the memory hex addresses (pre-stub dispatcher addresses and compiled method addresses), JIT compilations, and more. We looked at the Just In Time (JIT) Compiler optimizations, including register allocations, loop unrolling, dead code elimination, constant and copy propagation, and processor specific code generation. A new JIT optimization in v2.0 is range check elimination – not repeating range checking on arrays when the array is reused in an identical or safer manner (resulting in faster JIT compile times). Brad’s favorite runtime service (I’m guessing b/c this is the one he covered) is the Garbage Collector. Brad wanted to point out that a better way to think of the GC was to consider it a stuff collector – it copies everything that still has references and anything left behind is zeroed out. Brad then introduce Claudio, who would cover the GC in more detail.

Claudio Caldato presented how to write faster managed code. When talking about application performance, the following points are important to keep in mind. You need to set realistic goals and evaluate them continuously so they’re not too optimistic or conservative. You need to measure frequently. Know your platform to know where to make changes (memory, processor, etc). Performance improvements are not a one shot deal – make continuous improvements (automated tests help). Finally, build a performance culture – the developers need to understand that performance is part of their development process. Claudio talked about the garbage collection in action – maintaining objects with references and collapsing the memory queue to prevent fragmentation. Garbage collection works in a generational cycle. Gen 0 is run every time. Gen 1 is run only when Gen 0 doesn’t have enough memory on the heap to create all the required variables. The GC will pause threads, trace reachable objects from roots, compact live objects and recycle dead memory. Each generation is it’s own heap, so there are three Gen heaps and a large object heap (separated b/c moving large objects is expensive). To improve performance, make sure you understand the lifetime of your objects – don’t let them live to Gen2 if you can help it. Use perfmon and the CLRProfiler to examine your allocation profile. Some common pitfalls include keeping references to dead objects (be sure to null out object references). Implicit boxing (casting value types to ref. types) without knowing it happens when you do something like creating an ArrayList of Ints. Don’t do GC.Collect if you can help it. Because ~C( ) is not deterministic (you don’t know when the memory is cleared) you should try to use the Dispose pattern – implement IDisposable and call .SuppressFinalize. In C# this is as simple as the using keyword. Claudio showed us what he was talking about with some demos, using the CLRProfiler (available online for free). The demo also showed us explicitly how much the String.Append object method costs vs the StringBuilder.Append object method when modifying the string. The difference was astonishingly huge. The next demo showed the difference between the Finalize method and the using statement (which calls the IDispose interface). The point of this demo was to show how much memory could be saved by having deterministic memory clearing. We talked about Reflection a bit – noting that the new Token/Handle resolution APIs are very fast. An example would be calling MemberInfo on an object (a costly call), retrieving a token for that member, and then calling the Token API for future references to that object. COM Interop is efficient but frequent calls add up. This is because marshaling can be expensive. Primitive types and arrays of primitive types are cheap, but Unicode to ANSI string conversion are not. To diagnose some of these problems, you can use some of the built in CLR Interop counters in Perfmon. You can mitigate Interop call costs by batching calls (chunky, not chatty) or move the boundary (helpful if you control both the managed and unmanaged code). finally, some deployment considerations are to reduce the number of assemblies to speed load times, use the GAC to prevent repetitive signature verification, and use native code (NGEN) to reduce startup time and improve code shareability. Also, keep in mind that XML is not always the answer – System.XML.dll is 2Mb and might be overkill if you’re storing extremely simple data. When working with Performance Counters, start by looking at how much time is being spent in GC. 20% is too much. Next you’ll want to look at the promotion rate. If Gen2/(Gen0+Gen1) > 1/20 then look at the objects’ lifecycles. Next you’ll want to check the byte allocation to ensure you’re not above 30Mb/s under stress. This indicates too many objects. When using the CLRProfiler, examine the total allocation, the reallocated memory, the allocation graph, and the time line. To improve startup time, reduce the number of dlls loaded at startup (your own app dlls and .Net platform dlls), NGEN your assemblies to prevent JIT costs. Place strong named assemblies in the GAC. Finally, check your own application logic to see if your own computations are the bottleneck.

These guys are seriously smart. They’re so smart that just writing about them makes ME sound smart! Well, they’re product managers so you have to keep that in mind, but even so… I think they might each have more than one brain. Be sure to check out their blogs and books.

— Matt Ranlett
posted with BlogJet

C# User Group | User Groups

5/3/2005 10:00:34 AM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, April 27, 2005

Visual Studio Data Group Product Manager shows us the cool stuff

Big news announcements up-front:
CLR Team coming to C# Group – Monday, May 2nd
David Chappell coming to present the Indigo Roadshow at MS Building (instead of New Horizons) – May 18th
MSDN Event – May 19th

The job market really seems to be picking up – we had several people with job openings, including Microsoft itself!

The first presenter – Shawn Wildermuth was running late so Michael Earls stalled for time by showing us site maps and tab controls in ASP.Net 2.0 (both taking advantage of MasterPages). A sitemap is an xml file which defines the layout of a website. A cool feature of sitemaps is a new feature called security trimming – the ability to hide tabs or parts of a site based on a user’s security role. As far as the tab control itself, just include the new Asp:Menu control and you’re pretty much good to go! Michael showed us a quick live demo (complete with demo gremlin) of a three page site using a tab control. By setting the SiteMapDataSource control, you can tie your MasterPage to the sitemap.

Shawn Wildermuth showed up about twenty minutes late but he brought food so everyone forgave him. Shawn elected to give up his time slot to Alan Griver – the group manager for Visual Studio Data. Alan’s group is in charge of data views, designer connections to data, the SQL query tool, XML tools, Visual FoxPro, the Reporting Services report writer, SQL CLR integration, and more.

Last Thursday the VB team announced that VB is going to support refactoring in Visual Studio 2005. Alan’s first demo showed off a very simple VB app. VB Refactoring supports creating a constant, creating a local variable, creating a method, reordering parameters, inline temps (removing local variables). Not available with the latest Beta 2 download, you can download and install the refactoring support from http://msdn.microsoft.com/vbasic. The quick little demo (a tiny little app that calculates the area of a cylinder) was actually very impressive, complete with animations during the refactoring process. The slick refactoring capabilities are courtesy of Refactor! for Visual Studio 1.0. The out of the box VB.Net 2005 capabilities can be purchased for Visual Studio 2002, 2003, and C# 2002 – 2005 from Refactor!

The next demo Alan showed us involved the benefits of the background compilation. The example was the creation of a property with get and set methods. When the property was changed to a readonly property, the background compiler was able to symmantically check the code and show that the readonly property should have a set method. A smart tag showed up informing us of two methods for fixing the problem – removing the readonly attribute or removing the set method. Very nice.

The snippets demo was very nice as well – small amounts of code prewritten and insertable, complete with editable fields you can tab through. The example shown was the creation of an HTML e-mail. The fields were the TO, FROM, BODY, SUBJECT, and SMTPSERVER attributes. A snippet editor will be available but Alan wasn’t sure if the editor would be included in the package or if it would be a download from the new 2005 community site. An important point about snippets is that they can include comments

A tangential conversation covered the Ladybug project – a community bug tracking and submission initiative where the community at large can contribute enhancement and bug reports (and vote on them) which are fed directly into Microsoft’s internal bug tracking system. Another method of submitting feedback to Microsoft and the Microsoft user community is the Community menu option built directly into Visual Studio. There are links directly into Ladybug and into the Microsoft forums/newsgroups.

The next demo focused on a few neat Winforms tricks.

The first nice thing was the addition of the ability to specify a default data source type – once you pick SQL Server you don’t have to pick it again unless you need to change to something else.
Another nice addition is the ability to change views in the server explorer. This means you can change the default view to see an object view (tables, views, stored procedures, functions), a schema view, and more. This is to give you the same views you’d get in the datasource tools themselves. You can, for the first time, see Oracle packages.
When you use the wizard to create a new datasource, the connection string you specify is automatically saved to the app.config file.
The ALT+SHIFT+ENTER key combo gives you a full screen view
The Data Sources window allows you to pick columns and tables. New to Beta 2 is the ability for the Data Sources window to autodetect relationships within the data (ex. Customers -> Orders table relationship) and render them as such
The databinding example (complete with a demo of the winform layout enhancements) was really impressive. By dragging a few fields and an entire table (child relationship) onto the form, the text boxes, labels, and data grid view were all generated automatically. Even more impressive, a manually created text box can be data bound simply by dragging a data field onto the control.
The neat ability to data bind a combo box was really impressive – dragging a foreign key field from the parent child relationship onto the form creates a record bound to the parent record. By dragging the foreign key table onto the control causes a new binding source to be created – automatically binding the combobox to the table.
Windows projects can be made into single instance applications (preventing multiple copies from running at the same time) by simply checking a box in the project properties dialog
Application Events allow VB projects to be aware of app events like NetworkStatusChanged, StartupNextInstance (when the second or beyond instance of a program is started), and UnhandledException (an exception of last resort)
The new XSD data designer is really slick – strongly typed and complete with the ability to get to user data or create new stored procedures.
The XML editor is also really slick – if you specify a schema file (XSD or DTD) VS2005 will automatically create snippets for you. This way, if you open a node with 10 required child nodes and several attributes, simply by specifying the parent node you’ll automatically get an auto-generated snippet inserted into the code with tabbable fields.
XSLT can now be debugged from within projects. Microsoft has hooked XSL into the debugger by having it generate IL. This enables you to step from a C# debug session to an XSLT session back to a C# debug session.

The MY keyword works like a “speed dial” into the framework. For example, to play a song in the background (different thread) all you have to do for the thread generation is use the MY keyword with the Computer.Audio namespace. To get to configuration values saved in App.Config, just use the My.Settings namespace to have Intellisense access to the elements of the config files. Eventlogging is now built into the VB framework using the My.Application.Log namespace. You can easily see how the My keyword has the potential to greatly speed the development process. In fact, the MY namespace is actually extensible so companies can extend the MY keyword with their own business objects.

The final demo was of Object binding. Alan opened a new instance of Visual Studio and created a pair of classes using the new Class Designer (anyone remember WhiteHorse?). The Class Designer allows for a drag and drop GUI that allows quick class outlines. Drop a blue box on the screen to represent a class and use the simple list editor below to add methods and properties. Drag associations between the classes and “foreign keys” are created for you. The code is automatically generated. Back to the demo –> the new ClassLibrary was compiled and then included in the original data binding demo. From that point forward, the Intellisense and data binding worked exactly like the database data binding worked. Also, changing the code will automatically update the drawing.

Alan was a great presenter, willing to redirect his demos to answer everyone’s questions. The presentation was a quick overview of a tremendous amount of stuff, and there was no slideshow presentation for the .Net UG to post on their website.

We had great turnout tonight – 78 people came to hear Alan’s presentation. A familiar face at the UGs – Marcy the DataGrid girl is back in town. Everyone say “Hi!” I’m sure some of them showed up to hear Shawn too, but he’s a local boy now and doesn’t have the same mystique he once had. I wonder if Shawn’s still a Red Sox fan? Isn’t that a requirement of living in Boston?

— Matt Ranlett
posted with BlogJet

Scripting with VB.NET and VS2005 features

4/27/2005 3:44:47 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, April 26, 2005

VB.NET re-cap from 4/20/05. We checked out how to put scripting code into an Windows Form application. Stephen had a great test harness for using a function to perform a task based on the two variables he put in. He would change the script in the Windows Form and then take the script from the textbox and put that into the application. You could compare this to writing C#, VB.NET, or any other language on the fly. Something very similar that we talked about was using the CodeDom class to write code on the fly. Once we finished up with our discussions of how to use this in a business case we moved on to the new features of VB.NET 2.0 and VS2005. Dan gave an overview of some of the great new features like operator overloading. He demonstrated some of the features with demos and fielded questions about the new features that he had been looking at.

—Brendon Schwartz

Posted with BlogJet

The Atlanta Dot Net Book Club meets in the mall

4/26/2005 8:33:10 AM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, April 22, 2005

In the Perimeter Mall, over by Bloomingdales, there are several seating areas with sofas, coffee tables, and comfortable chairs. These are great spots to hold a small group meeting, as the Book Club found out. Several people can easily sit around a coffee table and hold an interesting conversation without having to move any of the chairs around.

Like all the previous book club meetings, the discussions were very free-ranging and open, covering large areas of subject matter. While not specifically discussing the chapters of the ASP.Net 2.0 book by Dino Esposito everyone is reading, we did talk about website design including 2.0 components such as membership services. The conversation started out of a discussion between Brendon and Keith – they are talking about their plans to build an events server that helps keep several user group websites up to date. The design discussions of this events server turned to web services and ownership of data. The question became, is it ‘better’ to have a central events server which gets directly updated by UG leaders and then sends down to the UG website a self updating calendar, or is it better for each site to be individually maintained and have the events server be nothing more than a central calendar that gets notified of updates by autonomous user group websites. The basic question here is, who should own the data, the UG website or the central server? Brendon and Keith (and I, for that matter) feel that UG leaders don’t really want to worry about maintaining their websites – there is so much to do when running a UG, and no one is getting paid to do it. So offloading a task like the website management (or a portion of the website) to a central server which handles data storage is preferable to each web site being responsible for maintaining their own data store. There was some dissent in the group initially, but I think we managed to sway everyone to our side. Look to Keith and Brendon for upcoming implementation details.

We also talked about notification services, or the lack thereof. One of the group members was complaining that he didn’t know when the new VS2005 Beta was released until several days after it happened. He was wishing he could have signed up for an e-mail from MS to alert him when this specific event occurred. A comparison was drawn to the Saturn car company. Saturn announced months or years ahead of time that it would be developing an SUV and people could sign up for an e-mail when the SUV was released. Why, the question was asked, couldn’t Microsoft do the same thing. After some initial bickering over which implementation method was better (e-mail or RSS) we all finally seemed to agree that the difficulty lies in getting an announcement for an event that is not yet defined. With both e-mail and RSS, unless someone at the company has the forethought to create a subscription point for that particular event, the only option you have as a consumer is to subscribe to a mass mailing list or general RSS feed. The analogy here is like looking to fill a small bottle of water from a fire hose. You end up with a listening service and some kind of keyword based raw text search. No one could think of a way to subscribe to an event that hadn’t been defined yet. Well, almost no one. Brendon actually has an idea about this and he’s writing a white paper he plans on submitting to Microsoft.

All in all, this was one of the better book club meetings because we not only discussed technology, but we discussed the technology from the book we were all supposed to be reading. We all hung around until about 9:00 when we noticed the mall closing around us. Check back with the book club website, a map of the mall with the meeting location will be posted soon. We enjoyed the location enough that we’re heading back there next time.

— Matt Ranlett

note – a comment was made in the book club meeting that some of Dino’s examples from the book wouldn’t work with the new Beta 2 due to some framework and tool changes. Take a look at this post from Shanku Niyogi – the ASP.Net group program manager outlining the Upcoming Changes to ASP.Net 2.0 in Beta 2.

.Net Book Club | User Groups

4/22/2005 9:39:03 AM (Eastern Standard Time, UTC-05:00)

Trackback

Win a Sony PSP handheld game system

I might be a bit late blogging about this, but better late than never. Apress is sponsoring a “User Group Puzzler” – the user group members can each individually create a crossword puzzle with 10 different Apress and friends of ED author last names. The puzzle should have 5 across and 5 down clues. One submission per person. For complete rules and to submit your puzzle, visit www.apress.com by April 30th

— Matt Ranlett

C# User Group with Threading and 2.0 - Apr 4, 2005

4/22/2005 8:39:12 AM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, April 06, 2005

The group seemed to grow to a standard “over 25” group; this is the second or third week in a row that all the regular seats were full. I have to say that says that Paul and Keith are doing a great job. This group is a great group for people to talk with each other at the beginning and at the break; I guess they have something in common, like computers. There were a bunch of new faces in the crowd and it was great to meet some of the local Atlanta Bloggers that showed up for the meeting. Keith and Paul gave the standard introduction and there were a few job announcements. Keith then jumped into his talk about Threading. I call it that because he mostly talked about classes in the System.Threading namespace. From what I heard from people in the audience the section on Locks was one of the best they had ever seen before! Wow what a compliment (Great job Keith and keep it up). After that we had a session of make the Microsoft man talk as much as you can and complain about the new products as much as you can. We asked questions about the next Visual Studio coming out and about how pricing might be structured. The funny part was we really didn’t have any concrete answer aside from the fact that he said they can’t give away a product that has taken a while to make. After we had finished announcements for Code Camps and asking the Microsoft Man questions we moved on to Mitch’s presentation on C# 2.0. Unfortunately we had spent so much time on breaks and other taking that he was not able to give his full presentation. He was able to cover generics and anonymous method calls both of which he did a wonderful job on. Hopefully he will be able to finish up the presentation at one of the other user groups. Make sure if you attend a user group that you go around and at least say hello to other people in the room, they may be interested in talking with you if you are interested in .NET.

-- Brendon Schwartz

C# User Group | User Groups

4/6/2005 10:53:16 AM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, April 05, 2005

Another happy C# User Group member

Check out the picture from last nights C# user group

http://www.cyanbane.com/2005/04/atlantas-c-user-group-20050404.asp

--Brendon Schwartz

User Group Idea for Enterprise Architecture

4/5/2005 1:52:45 PM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, March 30, 2005

I would like to try to get a session together where developers or architects in the community could come together and come up with some best practices and hands on approaches for designing systems. Here is my idea below.

Meetings would occur on a Saturday from 11:30 until 3:30. The cost of the event would be $5 dollars, unless I can find someone to sponsor the event. The $5 dollars would cover lunch from somewhere like the Atlanta bread company. The environment would be a round table atmosphere with a white board to write on. I would like every to give their input and suggestions so we can come up with the best solutions. And finally we would have one or more people at the event that would take notes on what is talked about and we could put this information into a document for the users of the group.

A topic idea for the first meeting could be something like: “How to create an ASP.NET Enterprise website from the ground up”

We could also follow along with the Patterns and Practices or the Guidelines from Microsoft. .

Let me know if anyone is interested. I was thinking about a group of 12 would be the right size, but I wanted to see if anyone else was interested in this.

-- Brendon Schwartz

.Net User Group gets Setup - March 28, 2005

3/30/2005 1:23:30 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, March 29, 2005

Over seventy people showed up for the third .Net User Group meeting of the year, the third in the new Microsoft Offices. There were snacks and drinks for all who attended and we got started after a few short announcements.

Doug Ware, user group leader extraordinaire, was the sole presenter of the evening as circumstances beyond anyone’s control prevented the main speaker for the evening from coming to discuss cryptography. But Doug was prepared with a free-ranging discussion of using Visual Studio’s Setup projects to create application installers. Beginning with a quick thirty minute overview and ending with questions from the group on conditional installation behaviors and Windows Management Instrumentation scripting with VBScript and Javascript, Doug managed to fill the entire evening with MSI installer education. Doug has lots of experience dealing with setup applications and he shared some of his hard earned wisdom. For example, Doug recommends that you don’t use a bootstrap setup (creates an .exe AND a .msi installer) as you are highly unlikely to find a machine WITH the .Net framework (required by any Visual Studio setup application) but WITHOUT the Windows Installer. Doug recommends you look into Orca, the MSI editor, so that you can change some behaviors of the MSI that Visual Studio doesn’t expose to you. Another of Doug’s tips is to pay close attention to the Launch Conditions dialog (because this badly named dialog actually includes 2 dialogs which can be used to help control conditional installer behavior). One final note – to get at some of the global variables defined within an MSI through script, check the Session.Property(“CustomActionData”) value. For example, to get the target install directory, you’d check Session.Property(“TARGETDIR”).

Since the main speaker for the evening was unable to show up, everyone went home after Doug finished his presentation and handed out a few prizes.

— Matt Ranlett

VB Group shows off how to do PDF in applications - Mar 23, 2005

3/29/2005 1:17:19 PM (Eastern Standard Time, UTC-05:00)

Trackback

Thursday, March 24, 2005

Traffic was bad so we had a slow start to the night, but since we had 3 presentations on reporting we had to get started at 6:30. Jim started the night telling everyone what we had in store which was Active Reports by Jim, Steve with PDFLib and XSL-FO and finally me with Reporting Services.

Jim started out with Active Reports which gives the end user the ability to create the reports in addition to the developers. The end users can create the report, but you will need to create the datasource in the back end ahead of time. You can pass in classes or objects instead of a datasource for people that use things like CLSA. Once you install active reports all you to do is add a new file from the Add New Item selection and then if you are familiar with access you are good to go. If you know Microsoft Access, Crystal Reports, or Reporting Services you should be very familiar with Active Reports. To add it to a winform all you have to do is create a winform and add the report to it. Active Reports by Data Dynamics. Standard Edition is about 499 and the pro version is 1299 per developer. All of development for Active Reports is integrated into Visual Studio 2003 so you don’t have to add anything new. The system comes with an end user designer with the professional version and gives the users the ability to create a report without have to install Visual Studio, but gives the same look and feel. Some things it doesn’t do well in version 1.0 is charting, they don’t give you the source, support is great, very quick and prompt, you don’t have drill down functionality. The features that Jim really pointed out was the fact that you can program against the entire coding model.

Although traffic was bad we still had a big crowd eventually show up. Note to self: A good thing to do would be to do a performance test against the reporting engines that most people use today. We had an announcement for Book247 at a discount again. If you show up to a group you may have a chance to get this discounted cost.

Next up was Steve with PDFlib. This presentation was all about creating PDF files. The version he uses is a COM component, but there is a newer .NET version. He pointed out that there are 3 ways to create a PDF file from a website 1) through an application like RS 2) component 3rd party product 3) XSLFO. He went on to show us the 3rd party version called PDFLib which costs 450 bucks. This version writes a file to disk with the information that you give it. We were able to see some of the object model for PDFLib, but when it comes down to it there are many options out there and it just comes down to price and features. He pointed out that these libraries do have a great place for on the fly changes and these libraries let you change options based on user input. Finally we got to see a small look at XSL-FO which is taking data and changing them to a formatting object. There aren’t many processors out there yet because this is still a new standard. The one that we were shown was an apache version that we had to run from the command line.

Finally I went on to show how you can use Reporting Services in your projects and how you can use the web service to embed the information into a webpage or winform. This is a good idea if you don’t want the end user to know the URL address or you want to have the report look like it is part of your webpage.

--Brendon Schwartz

P.S. I promise Matt will be back soon to do the review =)

MobilityUG with Cut and Paste and CF.NET 2.0

3/24/2005 11:16:33 AM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, March 22, 2005

We had a great turn out for the Mobility group, but had a rocky start. It was a cold winter day, ok so it wasn’t winter and it wasn’t really cold, but Matt and Michael were not able to make it. They both had circumstances beyond their control, so I went ahead and ran the show.

We had a great time learning about Mobility development for Pocket PC and had some great hands on demos. The first presentation was a great introduction to the problems of the current CF.NET Framework and some of the “missing” features. Venkat showed us how to add context menus for Cut and Paste to TextBoxes. He showed how OpenNETCF has implemented a lot of the “missing” features for Compact Framework. After a quick demo and showing the code required to make this work, we had our second presenter Kirk Evans come up. He claimed he was going to show the new “missing” features that CF.NET 2.0 will be adding and the enhancements that will make it worth checking out. If you are a mobility programmer and want to know what is coming in the next version you should have been at this meeting, I think they will post the slides on the Mobility site. Kirk went over what is coming in Visual Studio 2005 and showed some of new IDE features like being able to skin your app for the device you are using (cool). Even though Kirk was not feeling well he managed to give a great presentation that he claims he could do in his sleep. My guess is that he is that smart and probably could.

Once all the questions had finished we gave away some great prizes that Kirk had brought for us. Also we had someone announce a position for a Mobility programmer and if you are interested send the Mobility leaders an email and they will put you in contact with him.

--Brendon Schwartz

update ******

Great post about the first presentation and source code

http://vpolisetti.blogspirit.com/archive/2005/03/24/enable_contextmenus_automatically_for_opennetcf_textboxex_co.html

Mobility User Group | User Groups

3/22/2005 11:44:08 AM (Eastern Standard Time, UTC-05:00)

Trackback

Thursday, March 17, 2005

Atlanta area MVPs

At the book club meeting tonight there was a short discussion about being a Microsoft MVP. This got me to thinking… do we all know our MVPs? Do we even know what an MVP is? For those of us who don’t know, an MVP is an outstanding member of the technical community. These outstanding people are recognized by Microsoft for their willingness to participate and help other community members. These are the smart people around the world who write the interesting articles, newsgroup postings, and websites that we all read when we need help. *MVPs are not tested for their technical skills, this award recognizes only their community service efforts.

We have a ton of these folks in the Atlanta/Georgia area. I wanted to try to list a few of them out, but this is going to be an incomplete list as this information is not necessarily easy to come by. My apologies in advance for anyone who got left out or mistakenly credited for living in Atlanta. If you know something is off in this list, please comment on this post and I’ll update the main list.

Jim Behning – Small Business Server

Dave Bernard – Visual Foxpro

Tom Bishop – Tablet PC

Dana Coffey - ASP/ASP.Net

Thomas Divine – Windows Embedded

Mark Dunn – Visual Basic.Net

James Hambleton – Windows Embedded

Geoff Hiten – SQL Server

Teo Lachev – SQL Reporting Services

Dennis Rice – Tablet PC

Michael Sanford – Windows Server SDK

Jerold Schulman – Windows 2000

James Shaw – ASP/ASP.NET

Shawn Wildermuth – C#

Paul Wilson – ASP/ASP.NET

— Matt Ranlett

General | Programming | User Groups

3/17/2005 11:46:32 PM (Eastern Standard Time, UTC-05:00)

Trackback

Atlanta .Net Book Club meets for a pre-Introducing ASP.Net 2.0 talk

The Atlanta .Net Book Club got together at 5 Seasons Brew pub tonight for the last time. Not the last time that the book club will meet, it’s just that we’re not going back to 5 Seasons. Don’t get me wrong, I have nothing against the place, it is just time we find a new home nearer the other UG meeting locations.

Tonight we doubled our membership when SIX people showed up. That may not sound like a lot, but it’s actually a fantastic start. We made sure that everyone who came had a copy of Dino Esposito’s Introducing ASP.Net 2.0 book and we planned out our schedule of how quickly to read it. We all want to read about half or more of the book by the next meeting. We hope to have some interesting questions and maybe even some sample code to look at. The meeting in May (2 months from now) will be our final discussion of the book and the prep for the next book.

— Matt Ranlett

Reminder - Book Club meeting tonight

3/17/2005 11:45:53 PM (Eastern Standard Time, UTC-05:00)

Trackback

If you get this before it's too late, we hope to see everyone out at the 5 Seasons brew pub on Roswell Rd (just inside the Perimeter) at 6:30 for the Atlanta .Net Book Club

.NET Community | User Groups | .Net Book Club

3/17/2005 11:13:52 AM (Eastern Standard Time, UTC-05:00)

Trackback

Monday, March 14, 2005

SQL Server UG meeting, compliant in Year 2 (SOX) - March 14, 2005

Doug gave the announcements and talked to the group about SQL Connections and PASS – upcoming SQL conferences. Lots of jokes, a little bit of complaining about how salesy the last presentation was, and some thanks to our sponsors from Lumigent.

Harvey Parnell from Lumigent gave us a presentation on database auditing – an “essential business practice for Sarbanes-Oxley compliance”. Did you know that SOX compliance requirements within organizations have actually changed from the first year to the second year? In the first year of government regulated auditing, a lot of companies scrambled to meet the requirements. Frequently those requirements just couldn’t be met easily because there aren’t any products on the market which meet the needs. Basically, the Sarbanes-Oxley act dramatically changed financial reporting rules for public companies. In the second year (this year) there is a lot of focus on forcing accuracy of data down to the individual database level through automated tools and manual processes. The goal is to avoid future Enrons and Worldcoms (accounting scandals). As far as databases are concerned, the data contained inside of the financial applications are critical to the public organizations. Auditing attempts to prevent unauthorized access from both external and internal threats from happening, and if they happen they need to be monitored. Basically there are many auditing controls which are either violated or deficient. For example, development staff can run transactions in the production system. This brings to light the need to apply database auditing to all types of data access. That way, if something goes wrong, you know what the data was before the problem, what it is after the problem, and how to prevent the problems in the future. While tonight’s presentation focused on the Sarbanes-Oxley Act, there are other legislative requirements for auditing including the HIPAA (medical patient records), Graham Leach Billey Act and Basel II (personal financial records), and other regulations which require data retention for periods of time, such as seven years. After showing us how difficult it really is to monitor a database system as completely as one needs to be monitored, Lumigent’s staff told us how their application, the Entegra Auditing System meets as many of these needs as possible, with more features on the way.

Next Month – Shawn Wildermuth talking about CLR integration between Visual Studio 2005 (Whidbey) and SQL Server 2005 (Yukon). After several DBA-centric presentations, I personally will be happy to see something which speaks a little more to the concerns of the developers in the audience. Those who have seen Shawn present at the main .Net User Group or the Atlanta Mobility User Group know he is an engaging speaker. Come refresh your understanding of how the CLR integrates with the new Yukon database engine.

— Matt Ranlett

3/14/2005 9:59:40 PM (Eastern Standard Time, UTC-05:00)

Trackback

Saturday, March 12, 2005

March geek dinner set

The date and location are up for the Atlanta Geek Dinner this month. March 24th @ Harps Irish Pub.

Check out details.

Also the organizer Shawn has a post too.

--Brendon Schwartz

VB.Net User Group meeting - Mar 9, 2005

3/12/2005 9:36:56 AM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, March 09, 2005

The VB group is one of the only groups which is not meeting in the Microsoft offices. They get together in the New Horizons training center off of LaVista Road. Tonight’s meeting had a smaller group than usual. I’m assuming everyone is as busy as I am recently at work and just can’t spare the time. I know that we’re not talking about a lack of advertising – Brendon and I have been getting up in front of every single user group announcing all the upcoming meetings for the month. But I’m not discouraged by low turnout – quite the opposite. Every group has been experiencing record-breaking turnout recently.

Tonight’s meeting had three speakers scheduled but only two managed to turn out. And of the two that turned out, only one really had a presentation ready for display. That completely disorganized, unprepared presenter was me! But that’s a different story for a different day.

I was signed up to talk about the FileSystemObject how it differs from the System.IO namespace. The gist of my presentation was this – the FileSystemObject is actually part of the Windows Scripting Host. This is useful because it means that you can use the FileSystemObject outside of .Net applications. I showed an example of a VBScript file and a JavaScript program, both using the FileSystemObject to work with disks, directories, and files. The System.IO namespace offers more power and flexibility than the FSO does. For example, with the System.IO namespace you can get the extension of a file with the .GetExtension method. With the FSO you’ll have to search the file name string for the ‘.’ I didn’t have time to get a proper VB.Net sample project ready for everyone to see, so Jim came to my rescue. He had an application he uses to read in some bizarre custom format text files. He showed us how he could do the job with the FSO, a System.IO StreamReader, and a System.IO FileStream. We didn’t have a good way to measure performance, but the general feeling of the group is that the System.IO namespace would be faster than the FSO. If for no other reason, the FSO seems to require a COM Interop layer. For those of you who might be interested in how to use the FileSystemObject in JavaScript or VBScript, check out DevGuru.com – they have the entire object model of both scripting languages and more. Also, you should take a look at the Scriptomatic.

Brendon was the second speaker, presenting an interesting technique he found on the web to add custom properties to an enumeration. For example, he was able to create an enumeration of integers which had associated descriptions. This could be really valuable in cases like binary bit masking or error codes. With this technique you can have a meaningful description associated with otherwise bizarre enumeration values. I don’t have any links for examples of Brendon’s code yet, but he’ll be putting them up on the VB.Net site soon enough.

After the meeting we made our traditional pilgrimage to Chili’s for some food, drink, and talk.

— Matt Ranlett

C# User Group - Best Turnout EVER! - Feb 7, 2005

3/9/2005 10:23:44 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, March 08, 2005

Tonight we had the best turnout ever at the C# User Group. We had 27 people show up for the advanced topics of memory management and code dom. We really seem to be getting the word out about all of these meetings and lots of people are showing up.

First up to bat was Keith Rome who presented AppCenter Test to the group. He was demonstrating some memory and performance problems with a simple application that did some really horrible stuff with strings and integers (check Keith’s code to see why StringBuilder is not necessarily protection against bad coding). AppCenter Test was really easy to set up because he was able to simply record the input to his webpage. Then he opened the ACT tester and was ready to go. The reports that ACT spit out for us were really great, showing us graphs and charts of the results which were especially impressive when he compared multiple tests against each other. AppCenter Test is only available in Enterprise Architect editions of Visual Studio.

Following Keith, Mitch Harpur from MetaJunction showed us a 20 minute presentation of CodeDom. To begin with, you should know what the code dom is – the ability to write some code that actually writes other code (generated code). Code generation is very handy because common code (ex data access layers) can be easily generated. Once that kind of code is stable it will have less errors than code done by hand. Code gen also helps your code fit into templates and patterns. Code has some areas which are ideal candidates for code generation, but not every problem works with code generation. You’ll want to to look into the System.CodeDom and System.CodeDomGenerator namespaces. Mitch showed us an excellent example where he was able to generate a class with very little actual code. I tell you what, Mitch showed us that he is a very bright guy and I’m going to really have to work to find some real understanding of code generation. This seems like a really complex topic which is easy to get wrong.

Doug Turnure was our group’s pinch hitter – presenting memory management in C#. We started with a review of CS 101 and rapidly went into memory diagrams.

What’s the difference between a class, an object, and a reference?
What is a stack and what is the heap and where can you find the managed heap?
We sat together and walked through a simple code example to see how .Net will load up a type structure and initialise variable on the stack and the heap.
We talked about how the typestruct is internally a CoreInfoClassStruct – a vtable that points to code compiled by the JIT compiler and how once compiled that code is kept around and referenced directly by the vtable.
We talked about the difference between static vs instance members of a class and how static methods are faster than instance methods.
We talked about the difference between value types and reference types (ref types are objects that get GCed where value types are raw data and not objects).
Structures in .Net are faster than structures but you can’t inherit from them and you can’t replace the default constructor. One of the reasons structures are faster is that they are placed directly on the stack and are not pointed to on the heap. Structures CAN have methods and act just like classes.
We talked about coping or cloning objects. Shallow copy vs deep copy. Deep copy-cloning is easily done by serialising the object into memory and re-hydrating the object into a new ref.
Boxing is basically copying a value type just like it’s a reference type. Boxing occurs when you assign a value type to a reference value (ex – storing structs in an ArrayList). Unboxing is when you assign a reference type to a value type. The important thing to remember here is that boxing data creates a copy of that data and so if you change that boxed data you are not changing the original copy – it is up to you to synchronise those changes
Generics are objects where the type is defined later.
Garbage collection – Memory on the heap is allocated for (small) objects contiguously (that means really quickly) until there isn’t enough space on the managed heap. When you run out of space, unused objects (objects that have been orphaned when their references were set to null) are cleared out. Objects that survive garbage collection (because they’re still in use) are promoted from Gen 0 to Gen 1. When all the space is taken by Gen 1 objects, the GC will attempt to clean out all the Gen 1 objects and promote all the survivors of Gen 1 to Gen 2. When all the memory on the heap is full of Gen 2 objects, you’re out of memory! Garbage collection can be invoked manually, but in 99% of situations the automatic GC is more than sufficient. Always try to use a try..finalise which helps clean up objects. Also, don’t override Finalise unless you can’t help it – that’s slow! IDisposable is great but means your client code has to call it. That means you should implement both IDisposable AND a Finalise to ensure you clean up your object. You should also include a SuppressFinalize method as well.

The net conclusion of this talk is that Doug can crush you with his brain. Do not mess with Doug! Plus he’s funny even though he can’t be trusted with a marker and a dry erase board.

— Matt Ranlett

User Groups | C# User Group

3/8/2005 12:09:33 AM (Eastern Standard Time, UTC-05:00)

Trackback

Monday, February 28, 2005

February Atlanta Dot Net User Group - Atlanta UG Feb 28, 2005

Turnout for the February UG meeting was excellent and eye-opening at the same time. We had approximately 80 people in attendance once everyone managed to show up. Of the 80 people in attendance, nearly half of them were at their very first User Group meeting. I think that’s excellent! We seem to be doing a good job at getting the word out. Now it’s time to build up some dedication.

Shawn Wildermuth, Atlanta’s own ADO.Net MVP, whipped up a data driven Windows Smartphone application for the group. A demo in the truest sense (complete with gremlins preventing the demo from working at the last moment), Shawn wanted to show the group differences between traditional PC development and Smartphone development. The main difference Shawn hammered were the differences in data entry. A smartphone only has 12 buttons and no mouse. This really forces you to think about your application’s data input methodology very differently. Despite the demo problems, Shawn was gracefully able to continue his presentation and teach the group how to link a web service to his cellphone.

Dennis Hurst from SPI Dynamics (SPI like spy – they’re hackers) came to the group to tell us how a hacker breaks into a web application to steal your valuable data. Dennis explained to the group that hackers generally attack applications on one of three layers:

network (HTTP and HTTPS attacks). An important note here is that while SSL DOES guarantee that the data is encrypted and that it is coming from a valid server. What SSL does NOT do is validate the data inside the SSL pipe.
transport (messing with the HTML requests). This is where the cross-site scripting attackers steal your HTTP cookies and pretend to be you. This points out how critical your session cookies are. If one is hijacked, the hijacker can pretend to be you. *note – to destroy a cookie (and be sure it’s gone) overwrite it with a blank.
web application attacks actually come in three layers.
- platform – known vulnerabilities that can be easily exploited
- administration – have you configured the server correctly, are you giving out too much information in your logs and statistics, remnant files
- application vulnerabilities – how do you deal with input from users (ex – sql injection with a neat SQL Injector tool)

Dennis introduced us to Google hacking – the practice of using Google to find systems that are vulnerable. Cross-site scripting is an example of how phishing attackers steal your account information by fooling you into thinking that you are entering data into a valid site while sending the cookie to another site. Finally Dennis looked at Session hijacking – where a website thinks that the hacker is someone that they are not. This is not where the cookie is stolen, but rather when a repeatable session identifier is used and is changeable. Several real life examples of live sites that got this wrong (Guess.com and Victoria Secrets.com both got sued by the FTC for security flaws).

Dennis was a great speaker with very engaging demos. Look at the SPI Dynamics site for freely downloadable white papers. Search Microsoft’s site to find some webcasts he has done.

Announcements:
Check the calendar for upcoming user group announcements
March 24th – Geek Dinner!
May 14th – Atlanta Code Camp
May 18th – David Chappell is coming to town for an Indigo Roadshow. Plan to be there, this will be something you don’t want to miss.

— Matt Ranlett

VB.NET Study Group has Mail - 2/23/05 AVBSG

2/28/2005 10:53:31 PM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, February 25, 2005

The first presentation of the night was from John Crawford. John maintains http://www.gasports.com. He went over how send mail from a site that has many users and gave some pointers on what you might want to look out for. He demonstrated how you want to check for valid email address to log into a website. He pointed out that you want to have people register for the site and only send them email that they want or that you really must send them. Like the reminders for passwords. John took us farther into the world of running a large web server that requires many users that are on the internet. He gave us the low down on how to send email for many purposes from a large site to the end user. He uses class for .NET from OpenSMTP.NET, which is an open source free class for SMTP mail. You can use this open source class to send SMTP mail, but he added locking to make sure no errors occurred. For mass email he uses another webservice, which can handle large amounts of email in order to send out broadcast emails.

Jim gave a follow up presentation using the System.Web.Mail class in Visual Studio 2005, but said it could be done just the same in Visual Studio 2003. He did a quick on the spot demo of how to code a simple email application for either winforms or webforms.

The second half of the presentation was about how to create an application to manage Excel with Late Binding vs. Early Binding. I was the presenter so this post might be bias towards me a little bit. I showed how you can open excel, create a file, close excel, and read each line cell by cell. I had a bunch of questions so I am pretty sure everyone stayed awake. The point that really made a big difference was how much better VB.NET is for late binding than C#. I showed that to write an application using late binging in VB.NET all you have to do is change the variables from strong types into variables of type object. If you want to do the same thing in C# you have to re-write the entire application.

Check out the presentation material

--Brendon Schwartz

SQL Server UG meeting review, courtesy of David Rodriguez

2/25/2005 9:18:06 PM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, February 23, 2005

Unfortunatly, due to scheduling conflicts both Brendon and I missed the SQL Server meeting (they chose to move their meeting back a week rather than cancel for Valentine's Day. That meant they met the same day as the Mobility group). Since we couldn't be there I got this review of the meeting from David Rodriguez - the Microsoft guy at all of the SQL Server UG meetings.

"The presentation focused on SQL Server backup and system monitoring best practices. Part of the presentation included details on how Idera’s products support these best practices above the capabilities of SQL Server integrated tools. The slides for the presentation should be available on the web site for Atlanta.mdf

DRR"

Thanks David!

-- Matt Ranlett

MSDN Event photostory now on two sites

2/23/2005 3:16:10 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tuesday, February 22, 2005

I've updated the previous post as well. Now the MSDN Photostory Brendon put together is hosted on two sites:

Chris Wallace - http://tamasii.com/dotnet/feb2005msdnevent.wmv

Glen Gordon - http://www.msdn.tv/glengordon/feb2005msdnevent.wmv

Thanks guys!

-- Matt Ranlett

This Visual Basic is dead? Show up to the VB.Net study group and find out why you're wrong

2/22/2005 10:40:29 AM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday. 6:30pm. The New Horizons training center on LaVista Rd.

Or are you chicken?

— Matt Ranlett

keep an eye on the calendar – I’ll soon be updating it with the date, time, and location for the next Atlanta Geek Dinner

Atlanta Code Camp speaker forms

2/22/2005 12:05:46 AM (Eastern Standard Time, UTC-05:00)

Trackback

Monday, February 21, 2005

If you want to present to the community during the Atlanta Code Camp this May 14th, you need to download this form, fill it out, and mail it to Mark Dunn – mark AT NOSPAM dunntraining.com (sorry you can’t just click on the link – I’m doing my part to fight spam). This is true even if you have previously announced your intention to present. Your name doesn’t make it onto the final speaker listing without this form being in Mark’s hands.

— Matt Ranlett

The Atlanta Mobility Group discusses data access pragmatically

2/21/2005 11:53:39 PM (Eastern Standard Time, UTC-05:00)

Trackback

Before I mention anything else, I want to thank Doug Turnure and Microsoft for hosting us and ordering us pizza! Thanks!

Despite the truly horrific storm (we actually took a break so people could go move their cars to lower levels of the parking deck in case of hail) we had a great turnout. Twenty people came and participated in the round table discussion group style of presentation. We were very relaxed and informal tonight, peppering our presenters with questions in the middle of their presentations. I don’t know if they enjoyed it, but I sure like that style of presentation – the level of group involvement shows interest and attention.

First up on the big screen was Michael Earls. He presented an idea that he credits to Keith Rome. Basically, if you have a PocketPC device and want to watch movies (and with 1Gb compact flash cards, why not?), wouldn’t it be easier to do so with a Media Center type of interface? So Michael dreamed up the Pocket Media Center and downloaded the OpenNetCF classes from www.OpenNetCF.org. If you’ve never seen these tools before, you owe it to yourself to check them out, they’re one of the truly invaluable open source developer toolkits out there for anyone working with the .Net Compact Framework. In the course of his presentation, Michael learned a valuable lesson for all of us – the CE emulators which come with Visual Studio require a network connection or loop-back adaptor for communication and debugging to be successful. Michael’s short presentation was mostly dominated by people discussing the merits of the emulators and other developer toolkits they had experience with. The other toolkit I remember being mentioned was the GDI+ wrapper and charting tool set from www.XRossOne.com.

Our feature presenter for the evening was Shawn Wildermuth. Shawn is widely recognised for his database programming expertise, and using databases on the .Net Compact Framework was the focus of the talk this evening. Before delving into the actual methods of data access on the compact framework, Shawn pointed out some differences between the traditional networked PC and the mobile devices. Aside from the obvious differences - screen real estate and small memory room, there are other differences between the PC and the mobile device. Low bandwidth and range/access problems force you to think about your apps differently. Input restrictions (no keyboard/mouse) make you think differently. How you think about data has to change. The CF allows access to System.Data (Datasets) and XML, but not serialisation. The SQLClient requires connectivity. SQL CE allows offline data access but is not supported on the Smartphone platform. Web services do work on all the platforms.
Shawn's first demo was of the SqlClient. While the code looks remarkably similar to what you would write with the full framework. One caveat - there is no local cache on a mobile device. Of course, that makes sense when you think about it - you wouldn't want to cache lots of data on a memory restricted device.
Next up was a discussion of SQL Server CE - a database engine that actually runs a database on your mobile device. The neatest thing about it is that it uses HTTP for communication with SQL Server. SQL Server CE allows two methodologies when it comes to data access - either remote data access or merger replication. Remote Data Access is when you execute queries against a remote host. Merge replication is when you bring some or all of the database to the device and make your changes locally. SQL Server CE will handle sending changes to the server database. Something nice about SQL Server CE is that the database engine handles compression for you, making it easier to send larger amounts of data across the "wire"
Web Services as a data access method is really Shawn's preferred method for accessing data. Shawn really seems to like how much control he gets when he's designing his own web services. Of course, the trade off for this amount of control is an additional amount of code.
Other topics of conversation included data binding (slow on the CF devices so push this off to another thread!) and some new features promised in SQL Server 2005's SQL Server Mobile Edition. I won't go into all of the details of these two topics. Instead, visit www.adoguy.com and look for his presentations section - the presentation and all the code he showed us is available for download. Also look for his data factory class - he promised us that his magic base class for database work is freely available.

The evening wrapped up with some prize giveaways – no one walked away empty-handed. We had books, hats, t-shirts, notepads, and more all thanks again to Doug Turnure and his magical swag closet.

Be sure to join us next month for Kirk Evans present the upcoming .Net Compact Framework 2.0.

— Matt Ranlett

Making the calendar work for you

2/21/2005 11:40:22 PM (Eastern Standard Time, UTC-05:00)

Trackback

Sunday, February 20, 2005

I wonder if anyone else is obsessed with planning and organizing as much as I am. I have set up the calendar for people to download from our site for the Atlanta .NET events, but is that enough? Heck NO! There needs to be more options and more connections for people to be able to use the calendar in the way they want to, not the way I tell them they need to. That is the way I would feel if I was the person using the calendar.

Well I was signing up for a BizTalk event for tomorrow and they had a link to add it to my calendar. Now I know everyone has seen the little link you can make from Outlook to create an event file (.cvs), but I wanted to know how to really create one of these events. So I downloaded the file and opened it with Notepad. As expected I found text in the file and without hesitation I wanted to know what the specification of this file was. Luckily I found out that it is an open standard so I downloaded the developer reference and I am on my way to making a way for the website to allow people to add Calendar appointments to Outlook or any other program that uses vCalendar. I will be getting with Kirk who is the first person that told me that he had already looked into doing this with enclosures for RSS feeds, so I will hopefully get something going soon for people to have choices. I will post any of the code if it is good enough on www.devcow.com/projects when we are done with that section.

--Brendon Schwartz

.NET Community | Microsoft Products | User Groups

2/20/2005 10:00:55 PM (Eastern Standard Time, UTC-05:00)

Trackback

Saturday, February 19, 2005

Announcing a new feature of the Atlanta .Net Regular Guys - Tales from the Trenches

A little while ago Brendon, the local vocal community, and I came up with an idea to help bring us all closer together. Brendon and I, your humble Atlanta .Net Regular Guys, would invite some local member of the community out to lunch or dinner and chat with them about their personal experiences with .Net development. We'd then summarize and paraphrase that interview and post it to this blog for everyone to read. No one is sure about what will come of this, but we're hopeful that some helpful information might leak out. It might be interesting to hear what people around you but outside of your own development teams are doing, succeeding at, and struggling with.

"Tales from the Trenches" - beginning Thursday, Feb 24th.

Our inaugural interview will be Chris Wallace, a VB.Net developer who works as a one man development shop in the medical field. Expect the first post to be Thursday night or Friday. We are not sure yet if this will be a weekly or semi-weekly feature, but we intend to have some fun with this. If anyone has any interview topic requests, start sending them in!

-- Matt Ranlett

.NET Community | Programming | User Groups | Tales from the Trenches

2/19/2005 3:59:50 PM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, February 18, 2005

MSDN Event PhotoStoried

If you missed the MSDN Event we have tried to bring it to you in a new format I wanted to try out. I took pictures of the event and used Photo Story 3 to put it all together. With the help of Chris Wallace and Glen Gordon we are getting it hosted on the web. It is 7.5MB so you might want to download it before you watch it, but I tried to make it tell the story of the day. Let me know if you like it and if you would like me to do this for other events. Have fun!

Here is the link http://tamasii.com/blog/archive/2005/02/18/48807.aspx

I will post Glen's link when he puts it up. Thanks to both of you guys, any help is always appreciated.

--Brendon Schwartz

PS - the photostory is also being hosted by Glen Gordon - http://www.msdn.tv/glengordon/feb2005msdnevent.wmv

.NET Community | Microsoft Products | User Groups

2/18/2005 10:23:50 PM (Eastern Standard Time, UTC-05:00)

Trackback

Winter MSDN event gets warmed up

The winter MSDN event was a great success. Thanks to Glen and Michael for putting on such a great show. It was funny how this event started out. First I emailed Glen to get a head count so I would know how many flyers to print out about the local user group community. He told me 400 people were registered, which I thought was a large number. The next day Michael calls me on up and said “You should try to get here early if you can, if everyone shows up there won’t be enough seats”. So I left a couple minutes early and had no trouble getting in, actually I don’t think they would really turn people away unless it became really crowded, but I appreciate Michael looking out for me.

The presentations were excellent; it is amazing how much information you can learn from such an event, unless you are Keith and you know everything already, just kidding ;). The first presentation was about DataBinding. Actually have you ever wanted to write your own MediaPlayer and be able to change the look of your application? Well if you do you should have been at this presentation. Glen showed how to add some life to your products with new looks and the drag and drop functionality.

Next up was our local friend Michael Earls. It appears, or as the story goes, Glen changed some of the content on Michael so it was an exciting beginning. Luckily Michael can think on his feet quick and made it seem like it was part of the presentation. Good job on the presentation Michael. We learned some cool tips and tricks on debugging like how to break into a running ASP.NET application and how to use trace. I think trace is a great tool for everyone to use and if you don’t already know how to use check out the MSDN event content DVD. Keith who I was sitting next to said the funniest thing joking around while we were there, he said, “Trace is for the weak, real men use Response.Write for debugging”. This was a joke that Michael brought up in his presentation about the old way of doing trace in ASP applications.

The last presentation was a great intro and overview of what is soon to come with VS 2005. People are still waiting to see what the final release will have in it, but he did show the modeling tools and how to generate code from an architect’s point of view. It seems to me that .Net is really going to take off with VS2005 because they have so many features that help in the entire development cycle. This is really going to be a good area to watch for in the coming year for how to articles and what is good practice.

On that note look for Me and Matt to put out some posts on VS2005 over the next year we might start looking deeper into it and the new features that will help in your daily work. Also Microsoft has released “Microsoft Solutions Framework (MSF) for Agile Software Development, Beta” so check it out and let us know what you think about it and VS2005 in general.

P.S. – I will be working on getting the pictures and Photo Story to Glen who will post it for us somewhere because we don’t have the bandwidth for it. If you have suggestions for a back ground song let me know. An interesting guy I met at the MSDN event was Boris. He wrote a tool called Regmagik. Let me know if anyone else is using this. http://www.regmagik.com

--Brendon Schwartz

Atlanta Code Camp officially at capacity

2/18/2005 3:05:23 PM (Eastern Standard Time, UTC-05:00)

Trackback

Thursday, February 17, 2005

If you didn't already register for the May 14th Atlanta Code Camp, you are now too late. In just 17 days since the official announcement at January's Atlanta Dot Net User Group meeting, all of the spaces have been taken.

ATTENTION PRESENTERS: If you would like to present at the Atlanta Code Camp, we are still looking for you. You may request a space by doing one of the following things:

Add a comment to this blog requesting a speaker's berth
Send an e-mail to Mark Dunn (mark AT NOSPAM dunntraining.com) or Michael Earls (mearls AT NOSPAM hotmail.com) requesting a speaker's berth

ATTENTION PEOPLE WHO DID NOT REGISTER IN TIME: There is a waiting list that is already so long we'll never get through it. You have missed this code camp. I apologize from the bottom of my heart, but our venue has serious space limits which prevent us from opening more spaces. However, we are still looking for the following (which might get you entry to the code camp sessions)

volunteers to help set up before the event, manage the crowd during the event, and clean up after the event. If you are interested in volunteering, post a comment to this blog entry stating such. I do NOT guarantee entry to the code camp.

While we're still tremendously early in the process, I want to thank everyone for helping to spread the word and make this as successful as an event still three months away can be! If our successes continue in this vein, there will be more code camps in the future.

-- Matt Ranlett

.NET Community | Programming | User Groups

2/17/2005 11:32:02 PM (Eastern Standard Time, UTC-05:00)

Trackback

MSDN Event today a smashing success!

450 people signed up for the MSDN Event at Phipps Plaza today! That number is well over capacity at the theater, but several people didn't show up so there was still room to sit. Still, all the publicity seems to be working for Glen - more people are learning about his FREE developer training events and planning to show up.

Unfortunately I was not one of the people who could show up. My evil boss required me to be at work today so I could only attend the after-party. I, and about 50 of my closest friends, congregated at the American Cafe underneath the AMC theater in Phipps Plaza. Microsoft was kind enough to purchase some free appetizers for us (Thanks Glen!) and give away some prizes. Everyone at my table won something except me! That's what I get for not showing up to the event, bad karma.

Brendon will be posting a blog entry to cover the actual MSDN Event content as well as some photos he took. He'll probably get those up in the next day or so - he's actually visiting with his Grandmother tonight. Hello, Brendon's Grandma!

Upcoming meeting reminders!
Monday the 21st - Atlanta Mobility Group. Shawn Wildermuth presents ADO and the Compact Framework.
Wednesday the 23rd - Atlanta Visual Basic.Net Study Group. Brendon and I tag-team the group with presentations.
Monday the 28th - the main Atlanta Dot Net User Group meeting, featuring Dennis Hurst teaching you how to hack (ok, maybe not)
May 14th - Atlanta Code Camp - sorry, already filled up!
May 18th - newly announced Wednesday visit from David Chappell to discuss Indigo. This will be a great session and takes the place of the end of the month Atlanta Dot Net User Group meeting (May 30th is now a free Monday night).

-- Matt Ranlett

Does anyone think I went a little too far with all the links in this post? Aside from me, that is?

BREAKING NEWS! - Atlanta Code Camp Sold Out

2/17/2005 11:19:51 PM (Eastern Standard Time, UTC-05:00)

Trackback

Seventeen days after the official announcement of the Atlanta Code Camp, all the spaces have been filled. We had 200 spaces available and those are now gone! We actually have a waiting list! I think that's totally awesome! Way to go, Atlanta!

Another planning meeting happens next week and we'll begin sorting speakers into the tracks and deciding who presents what and where. Look to www.AtlantaCodeCamp.com for these details as soon as they become available. I'll also be posting that information to this blog.

-- Matt Ranlett

.NET Community | Programming | User Groups

2/17/2005 11:42:05 AM (Eastern Standard Time, UTC-05:00)

Trackback

Wednesday, February 16, 2005

Atlanta Dot Net Regular Guy Calendar updated

The calendar of Atlanta .Net user groups and events has been updated at www.devcow.com/calendar. The calendar now is complete through to December and should be accurate.

New to the calendar - the Atlanta Code Camp and a May 18th visit from David Chappell for a talk about Indigo.

Note: the downloadable calendar is not quite as complete yet. Stay tuned for more updates.

-- Matt Ranlett

2/16/2005 1:50:03 PM (Eastern Standard Time, UTC-05:00)

Trackback

Monday, February 14, 2005

Tales from the Trenches

Brendon's stirring of the pot with his Rockstars post lead to a great idea buried deep in the comments. How about this:

"Tales from the Trenches"
A series of interviews, in person, online, or via the phone, with user group community members. The focus of the interviews will be the current and past projects that individual is working on (no trade secrets please). We'll focus on that particular user's challenges and triumphs. The resulting blog posting will provide the community at large with an insite to what's happening in the Dot Net world around them. This might also result in an e-mail exchange between our interviewee and community members at large who might be facing the same challenges.

What do you guys think? Here we'd have the opporitunity to interview independent contractors, consultants, on man shops buried inside of large organizations, and developers working with large .Net development teams. We'd pay no attention to any sort of "Who's who" list - just start with our blogroll and branch out from there.

-- Matt Ranlett

Geek Dinner has few attendees but all are great people

2/14/2005 9:25:42 AM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, February 11, 2005

Last night’s Geek Dinner did not have many people last night, but the people who did come were all great folks. Shawn Wildermuth, Atlanta’s resident MVP on ADO.Net, planned the event and came armed with loads of trivia about old TV shows. Mark Dunn, a Visual Basic.Net MVP, showed up with even more TV trivia. Keith Rome, Michael Earls, and I made up the rest of the dinner crowd. We talked about music, TV, programming, and the Atlanta Code Camp. On the topic of programming, I wanted to point this out to the masses who read my blog (and don’t read Shawn’s b/c he’s already posted this). Check out the OldNewThing blog on MSDN for some really cool code and code history.

Back on the topic of the low Geek Dinner attendance. I’m wondering if we’ve got too much of a good thing going on here. If memory serves, when we had one or two Geek Dinners a year the attendance was about 25 or 30. Now that we’ve gone to one a month, attendance has really dropped. Should we cut back the number of events? Do we care if people don’t show up? I, personally don’t much care – I’ll show up every time I can. What does everyone else think?

— Matt Ranlett

February Book Club meeting cancelled

2/11/2005 2:03:03 PM (Eastern Standard Time, UTC-05:00)

Trackback

Thursday, February 10, 2005

Due to the MSDN Event and .Net Pub Club happening on Thursday, we’re skipping February’s Book Club meeting. The website will be updated when Brendon gets back from the Caribbean.

— Matt Ranlett

Keeping the Visual Basic group Regular

2/10/2005 12:33:59 PM (Eastern Standard Time, UTC-05:00)

Trackback

The VB Group began with a quick demo of the Erl() function, showing the group how line numbers and Erl() can simplify debugging inside of VB code.

Following this quick intro demo, we had some announcements:

Feb 17th – MSDN Event
Feb 21st – SQL Server UG and Mobility UG
May 14th – Atlanta Code Camp

First up at the presentation podium was Dan Bredy who showed us how VB.Net implements regular expressions. Dan’s main focus for regular expressions was pattern matching on large blocks of text. The group looked at the RegEx class, captures, matches, and groups. Dan actually frequently uses regular expressions to turn text files from Project Gutenbueg into HTML documents which can be read by IE or compiled into the Microsoft Reader .lit format. Other common uses for regular expressions inside of .Net projects include input validation on web forms (making sure phone numbers and e-mail addresses look correct) and URI path validation. Check out the site www.regular-expressions.info for tutorials (language agnostic) and www.regexlib.com for samples and the Regulator – a tool for testing and researching regular expressions. Regular expressions are a specialised language unto themselves and are extremely powerful when used correctly.

The next presentation was Richard Greene who demonstrated the difference between passing arguments into functions by value and by reference (article in C#). While in general an easy to understand difference, we showed that passing objects by value didn’t necessarily protect the contents of that object. That’s because objects are reference types – you don’t pass copies of the object. Instead you are passing references, or pointers, to the object. This means that and changes to that reference type object occur in the same memory space as the original object and the “copy” of the object outside of the function changes too. We also briefly glanced at the topic of deep vs shallow copy, where a deep copy of an object makes a reference type behave like a value type. The example of this was the String class. The overridden assignment operators of the String class allow you to pass the object (which is by definition a reference type) to functions which define parameters as ByVal. In this case, the String object behaves as if it were a value type. The discussion here didn’t really cover boxing and unboxing or memory management and garbage collection – the logical next steps in any discussion of the treatment of value and reference types. Maybe a future presentation will bring more in depth understanding to the group. Understanding what happens under the covers and how your variables behave is essential to your development as a software engineer.

— Matt Ranlett

PS – up next time are discussions on COM Interop, the System.Web.Mail namespace, and the System.IO namespace. Show up and learn something!

C# UG in Norcross, I mean Alpharetta

2/10/2005 10:40:02 AM (Eastern Standard Time, UTC-05:00)

Trackback

Monday, February 07, 2005

After some confusion about the meeting location for the C# User Group (the initial meeting location became suddenly unavailable), Paul Lockwood let everyone know that the C# group would be meeting at the Microsoft Offices in Alpharetta. Paul did a great job of scrambling to get our location secured in the final moments before the meeting.

First up at the presentation podium was Keith Rome. Keith had a great presentation on how to build an add-in for Visual Studio itself. He had a great business need – to manage large blocks of unchanging text strings within source code such as HTML or SQL. Unsatisfied with the built in resource manager, Keith built an addin called NVEdit (for editing Non-Volatile data).

After Keith was finished with his demo and presentation the group discussed it’s future locations, format, and the kinds of presentations we most wanted to see. Keith Rome and Paul Lockwood travelled to the Florida Code Camp and spent time in the airport discussing what topics and meeting formats they might most like to see in the future. They popped off some great ideas, including a “code bruise” format, where we have multiple short presentations followed by a longer, more in-depth (traditional) presentation. We’ve got the three topics for the March meeting planned out and we’ve even got one or two of the presentations for the April meeting all planned out. Next month our feature presenter will be none other than Mr. Doug Turnure himself! Be prepared for an under the covers exploration of .Net memory management and garbage collection. Paul was very serious when he said he was ratcheting up the technical content in these meetings. The C# group is not the place for newbies!

— Matt Ranlett

Continuous reminder mode:

Feb 14th – Valentine’s Day! Be sure you have dinner reservations AND/OR chocolate. No SQL Server group

Feb 17th – MSDN Event at Phipps Plaza followed by a .Net Pub Club event

Feb 21st – Atlanta Mobility UG meeting featuring Shawn Wildermuth at the Microsoft office.

May 14th – the Atlanta Code Camp!

February's User Group Meetings

2/7/2005 11:02:04 PM (Eastern Standard Time, UTC-05:00)

Trackback

Friday, February 04, 2005

I just wanted to remind everyone that the C# User Group is meeting this coming Monday, the 7th. Check the website for directions to the meeting location. The following Monday, the 14th, is Valentines’ Day, so the SQL Server group has pushed back their meeting by one week. That means the Mobility group and the SQL Server group are meeting on the same day, Monday the 21st.. I personally will be at the Mobility group, ironically listening to Shawn Wildermuth talk about data access and ADO.Net. Last Monday of the month is the main .Net User Group meeting at the Microsoft offices.

— Matt Ranlett

ps – check the schedule at http://www.devcow.com/calendar

FREE MSDN Event -- Planning ahead

2/4/2005 8:31:34 AM (Eastern Standard Time, UTC-05:00)

Trackback

Sunday, January 30, 2005

Usually we write about what has happened not about what will happen. Maybe that is because we are computer programmers and not fortune tellers. Well times have changed and we are trying to get the word out to everyone in the community about the next FREE MSDN event. This time Glen Gordon is bringing Michael Earls to show off some of the demos. We hope that you will go and even if you can’t, tell your friends and co-workers about the event and help get people out in the community.

— Brendon Schwartz

VB.Net group lead by the Regular Guys

1/30/2005 4:10:39 PM (Eastern Standard Time, UTC-05:00)

Trackback

Jim Wooly was out of town so he called on the Regular Guys to take over and run the meeting. We were only too happy to oblige.

I started the meeting out by turning it slightly on it’s ear and asking the people at the beginning of the meeting what they might like to hear presentations on. I took part of the list we read out at the end of the year and re-presented it to the group. I mentioned topics like debugging SQL stored procedures from Visual Studio.Net, garbage collection, message queues, the FileSystem object vs System.IO, generics in Whidbey, and Reflection.Emit. Those are actually larger presentations, and we had some interest in something Paul Lockwood called “Code Bruise” – where groups of people each present small 10 or 15 minute presentations on immediately practical code. Examples of interesting topics were how to put an app into the system tray as an icon, how to serialize something, shallow vs deep copying, how to register a DLL to the GAC (and why).

Paul was our first presenter and he showed us NUnit. We’ve actually seen NUnit once or twice before but there were several reasons to revisit this. First of all, this is a free tool which will make your code more stable, solid, and therefore easy to work with. FREE TOOL = EASY CODE! Second, developer level unit testing is a huge topic, seen in MSDN at least once every few months and is being built into VS.Net for C#. Third, Paul champions a much more maintainable approach to NUnit than what was originally presented (by myself) months ago. His approach is to do black box testing, that is to say testing of large areas of functionality as opposed to the extremely granular approach I took with my white box testing of every single function (although his demo was too short to really expound on this). Paul also showed us how to create a brand new project and add an NUnit test.

My presentation followed Paul’s. I showed off some of the free tools from SysInternals. This time, in a break from my normal type of presentation, I only had 4 slides and some demo code. I mostly showed off the ProcessExplorer. Great developer tools freely available from www.SysInternals.com. The demo code had some small problems, but what demo code doesn’t? The main problem was the total lack of error handling. Oh well – lessons learned for next time.

Following the meeting, Brendon, Dan, and myself retired to Chili’s for some food and conversation. Most of the conversation this time was development-centric. We spent a lot of time discussing the upcoming code camp. I’m very excited about this event! I’ll blog more about it when more details are public.

— Matt Ranlett

Books discussed by the Book Club Meeting

1/30/2005 4:09:29 PM (Eastern Standard Time, UTC-05:00)

Trackback

Since the group was small, talk frequently wandered away from books in general. Actually, it would be more reasonable to say that talk barely ever grazed the subject of books. While we did bring up Microsoft Press’s Object Thinking and the Martin Fowler Refactoring books (Refactoring and Patterns of Enterprise Development), most of the conversation was about BizTalk and other technical topics.

Everyone agrees – BizTalk is cool. Everyone also agreed that we personally hadn’t been convinced enough to care. BizTalk seems to be for larger companies and larger contracts than the people at the table were likely to see in the short term.

After that fun topics of conversation included college pranks, Internet access speeds, ex-coworkers, naps at work, home values, and more.

We’re not sure that we found the perfect location yet but we’re very happy with the quality of the food and beer at the 5 Seasons brew pub.

— Matt Ranlett

Worst planners of the Year Award

1/30/2005 3:38:56 PM (Eastern Standard Time, UTC-05:00)

Trackback

Brendon and I deserve to win the worst planners of the year award because of the Atlanta Dot Net Book Club – we picked the only night that 5 Seasons had reserved the ENTIRE bar area for some kind of private party. So much for us picking the easy area to find. Oh well, Keith was able to find us sitting at the bar, so it can’t have been that bad.

— Matt Ranlett

MSDN and my presentation Resolution

1/30/2005 3:37:48 PM (Eastern Standard Time, UTC-05:00)

Trackback

When it comes to the User Groups and my past presentations, I've done some with code and some without. Actually, many of the recent presentations were on topics where no code was necessary or possible. But my new resolution is that every presentation I do from now on will have half the PowerPoint slides and at least 20 minutes worth of GOOD code demonstrations.

That brings me to MSDN. This is an awesome resource for those of us who want to present topics. Lots of the work is done for you and you can easily extend these articles into a worthy presentation. Even if you don't extend the topic beyond the scope of the article, lots of people don't read MSDN as often as they should. For these people, a straight presentation of an MSDN article would be a fantastic way to learn something they might otherwise have missed.

At the last VB.Net UG meeting we had 2 brand new presenters. I hope they learned that presenting in front of the group isn't as scary as they thought and that they want to do it again. I'm just here offering suggestions for finding future presentations.

-- Matt Ranlett

Programming | User Groups

1/30/2005 3:10:00 PM (Eastern Standard Time, UTC-05:00)

Trackback

The Code Camp Cometh

Prepare yourselves!

At some point in the next 2 to 6 months we will be hosting a Code Camp in our fair city. Things are still in the early early planning stages, but take a look at the Florida Code Camp's lineup. If the Atlanta Code Camp get's even half as good a lineup it will be a can't miss event.

Speaking of can't miss events, let's chat for a moment about the local developer community. We've got tons of awesome tech firms in the area. We've got dozens of “famous” developers in the area. Atlanta has several Microsoft MVPs. Why is it that we don't get many of these people at our local area user groups? I go to pretty much EVERY UG meeting and we've topped out at maybe 120 people at a single UG meeting. Most of the time we hover between 15 to 40 people per meeting, and a lot of these are the same people showing up at multiple groups. Come on, people! Start showing up to some of these meetings! They're a free resource for you and even if you don't use a single thing you learn at these meetings, I promise you that you'll learn SOMETHING!

With few exceptions, Atlanta seems to be a town full of lazy people. We don't support our local sports franchises and we don't support our local user groups. The user groups are FREE! Most of them have their acts together enough to post what the next topics are at least a week in advance of the meeting. Keep up with the websites and plan to attend at least one UG meeting a month. I promise it will be worth it. And when you come, drag someone along with you. The first meeting I went to, I was dragged to by a friend. Now I'm hooked. I've managed to drag three or four other people along occasionally and they always enjoy themselves.

Paul Lockwood does an excellent job of maintaining a calendar of upcoming events in town. Keep tabs on the calendar and plan accordingly.

-- Matt Ranlett

General | Programming | User Groups

1/30/2005 3:07:59 PM (Eastern Standard Time, UTC-05:00)

Trackback

Everyone has a Monday off

Just a reminder - next Monday there is no UG meeting. This won't happen again until May 23rd (the next month with 5 Mondays) so take the time to be with your families. Those of you who may be going through UG withdrawel are free to attend the Wednesday meeting of the Atlanta Visual Basic.Net Study Group where Paul Lockwood and I will be the feature presenters.

-- Matt Ranlett

The Atlanta Dot Net Book Club rises from the ashes

1/30/2005 3:07:01 PM (Eastern Standard Time, UTC-05:00)

Trackback

Like the phoenix, we're coming back from the dead. Two months have gone by since we had a meeting but we're going to have one this month. This Thursday (that's tomorrow, people!) we're going to meet at 5 Seasons in the bar area. The bar offers free wireless Internet access and is easy to find. We have not told the restaurant staff so don't go asking the hostess, she won't know what you're talking about. Just go into the entry and turn left. We'll be there.

-- Matt Ranlett

PS - I'll get Brendon to update the website

Awesome turnout for the Mobility UG

1/30/2005 3:06:18 PM (Eastern Standard Time, UTC-05:00)

Trackback

Unfortunately I had to drive back into the office as soon as I got there, but I was able to help our consumate host Doug Turnure lug tchotchkes into the meeting. I got to see Jorge Sierra of www.SierraCode.com presenting his mobile QuickBooks POS solution to the group. Jorge is a C++ programmer and was attempting to show the group how difficult it is to create a polished mobile solution with embedded C++. Of course, Jorge is a gifted developer and what's difficult for me might be a cakewalk for him.

After Jorge presented for about 30 minutes, Michael Earls got up to give a presentation. The presentation of XAML was unfortunately not ready to be shown, as it resided on an external harddrive Michael reportedly left on his kitchen counter. Despite the missing XAML, Michael was ready with another mobility presentation (courtesy of Doug T).

I am sorry that I had to miss the meeting and the snacks afterwards, but I can report that POS2 at Store 8501 down at the client site DID in fact lose nearly 100 transactions with no easy way to recover the data. That's what I was working on while the rest of the group was grilling Jorge and Michael.

This Thursday is the Atlanta DotNet Book Club meeting. We're meeting at 6:30 in the bar area of 5 Seasons. Hopefully Brendon has updated the website (I haven't checked yet). I don't know what books we're covering, but I'm unwilling to let this book club idea die so we'll be planning out the coming year if nothing else. Show up and learn about how you can read computer books for fun and maybe even get a free book or two.

-- Matt Ranlett

Fresh meat at the VB.Net Study Group

1/30/2005 3:05:36 PM (Eastern Standard Time, UTC-05:00)

Trackback

Tonight's Geek dinner

Shawn Wildermuth has been doing a great job of bringing stability to the Atlanta Geek Dinners. Check out the blog on the NerdDinner.com site to keep up. The reason I mention this is that we're meeting TONIGHT! 6pm at the 5 Seasons Brewery on Roswell Road. Everyone better be there!

-- Matt Ranlett

General | User Groups

1/30/2005 3:01:30 PM (Eastern Standard Time, UTC-05:00)

Trackback

Yesterday at the VB study group we had two BRAND NEW presenters! Yay!

Jake (last name omitted to protect the innocent) showed us his favorite tool, Visual Assist X, from www.wholetomato.com (free trial download). Visual Assist X is much like an enhanced version of Intellisense - it tries to auto-complete practically every word you type. I can easily see how this will speed your coding. More than that, it allows acronyms, custom color coding, spellchecking, macros, and more.

John Crawford showed us his side project - www.GASports.com - a news and scheduling site for high school sports statewide. The problems John faced were surprising complex. First of all, he has about 8000 to 10,000 coaches across the state inputting data. These are high school coaches, so he wanted to make the data entry phase as simple as possible. This requires some client side data validation using JavaScript. John will be the first to admit that he's not an expert in JS and he doesn't really want to be. Secondly, the computers used by various high school coaches across Georgia are anything but standard, so he needed to support IE, Netscape, and if possible other 3rd party browsers. So he went looking for some free or commercial tools to meet his needs. We saw four of the controls he is using to control his site. First up was a menuing control. The current implementation is data driven and too large. The new solution (from www.skmMenu.com) is an XML driven drop down menu control. Very clever. Components 2 and 3 were date and time pickers. The current controls are from www.excentrics.net and are very flexible and customizable. The final control is a combo box. Combo boxes don't exist on web forms, just dropdown lists. But John's needs included the ability for coaches to add new schools as required (when the southern-most schools play teams from Florida) so he needed a Combo box. He grabbed the control from www.prog-studios.com and is happy with it's performance in IE. The problem is that the combo box he's currently using doesn't support Netscape.

Following these two guys up was yours truly. I presented Coder to Developer by Mike Gunderloy. Much like a survey course in what is required to be a professional software developer, Coder to Developer is written to introduce the reader to all the things a developer's job includes outside of just writing code. This includes things like Source Code Control, Code Generation, Unit Testing, IP licensing and contracts, etc. I wrote up a short little slide show (using my trademark green background) which will be posted on the VB group's website.

After the meeting, four of us went to Chili's where we had some food and talked about sports, cars troubles, and work in general.

-- Matt Ranlett

Monday's SQL Server UG meeting

1/30/2005 3:01:01 PM (Eastern Standard Time, UTC-05:00)

Trackback

This Monday saw another meeting of the Atlanta MDF group at the Intellinet office. Doug did a great job running the meeting and was the main presenter for the night. We opened with a quick presentation from our sponsor InterCerve - they're releasing version 2 of their great tool SQLSentry. My favorite feature that I saw in the overview was the awesome scheduling interface allowing you to see in an Outlook style calendar all of your jobs across multiple servers. Brilliant stuff and well worth you checking out. There is a free 30 downloadable version - give it a try.

After the sponsor presentation, Doug gave a great lecture on how to optimize Reporting Services solutions. We talked about scheduling and caching reports, using stored procedures, licensing requirements, and way more. I should have been taking notes, but I think he posts his presentation online so go check the website at www.atlantamdf.com. We had about 40 people in attendance and lots of those heads were nodding in agreement along with Doug as he pointed out how to get improvements in speed.

-- Matt Ranlett

The C# group kicks back and blasts aliens together

1/30/2005 2:58:50 PM (Eastern Standard Time, UTC-05:00)

Trackback

This week the C# group was small and still recovering from the holidays. Rather than present a prepared technical presentation, we decided that Chinese food and Xbox should be the order of the day. Actually, the order was more like Xbox (watch out for Sanin in Halo - he's a great sniper), Chinese food (where Keith talked about how he was forced to second guess the GC process), and then more Xbox (Don't ever play Unreal with Michael E. - he kicked my butt and it's my game!)

The C# group met at my place since we didn't want to drive up to the new MS offices on Mansell Rd. We're looking for a new place, and we've set Paul Lockwood (with his amazing list of contacts) on the task. I think he's already got something up his sleeve.

Just a heads up for the next presentation - Paul wants to give us a Round 2 presentation on NUnit - Advanced Unit Testing. I don't get to use anything like NUnit on a daily basis but I love the idea. I'm looking forward to the presentation - he's always got a great knowledge of what he's presenting. Well, ok, most of the time he knows what he's talking about. Just don't ask him anything about cars. I don't think he quite has the hang of those yet. Kidding! He's got to be the most knowledgable car nut I've ever met, and I used to be friends with a mechanic!

I'm glad we managed to get together for the meeting. I had a great time kicking back and I think that it put me in the mood for some more UG meetings in general. Next up - SQL Server on Monday and VB on Wednesday. The SQL Server meeting will focus on optimizing Reporting Services and the VB group will mostly be looking at addins and toys. I'm supposed to present a book review but I haven't read a book (a technology book) yet so I'd better get to reading!

-- Matt Ranlett

1/30/2005 2:55:30 PM (Eastern Standard Time, UTC-05:00)

Trackback

Mobility meeting wrap-up

Paul Lockwood really stepped up for this meeting. He used his extensive network of contacts to secure us a room in TechDiscovery's offices. Big thanks to the guys at TechDiscovery for hosting us (some of them even sat in on the meeting).

We had about 10 people show up for the meeting (13 if you add in the guys from TechDiscovery), all of whom were developers. We were especially pleased to welcome Michael Earls back to the Atlanta (Geek) Scene. Michael just came back from San Francisco and he brought with him a Creative Portable MediaPlayer. Badass! What more could you ask for - a 20 Gb drive capable of playing infinite music and movies. He's recently been using it in conjunction with RSS Enclosures (podcasting) to autoload the device with all his training videos. If I hadn't just bought a tablet I'd be out in stores looking for one of these.

Paul kicked off our meeting and introduced our hosts to the group. The guy from TechDiscovery (I apologize, but I forgot his name) said that they were hiring! They're looking for a few good .Net men. And women.

After the intro, I gave a presentation on Tablet PCs. I wanted to focus on the usability rather than the programming side of things at the first meeting. Get people to see what's already out there and why tablets are so cool. I showed off OneNote, Speech Input, MS Journal, some of the power toys, and ArtRage. Got some great comments from the guests, especially when I passed my tablet around for some hands on time. I did spend a bit of time showing them the InkEdit and InkPicture controls. Microsoft has just outdone themselves. It's so easy to create Ink Aware applications, I'm almost embarrassed. Fantastic!

We wrapped up the meeting early with some general comments about the upcoming meetings. We've got Keith and Shawn coming up in January and February. Should be great stuff and I'm looking forward to both.

Michael, Brendon, Paul Lockwood, Paul SomebodyElse (can't remember the last name at the moment) and I went to 5 Seasons for some tasty beverages and a bit of a chat. We had a great conversation about how DRM was both the greatest thing and the worst thing simultaneously. The gist of the conversation was that DRM enabled content providers to feel safe releasing media content online while at the same time it invites tracking and potential abuse snowballing into an Orwellian fascist state run by the big pigs. Good stuff. That and we talked about batteries. Man, sometimes I'm just stunned by the geekiness. Good stuff!

-- Matt Ranlett

1/30/2005 2:53:04 PM (Eastern Standard Time, UTC-05:00)

Trackback

Holiday craziness

Wow, I'm going to have to stop and catch my breath. It's been crazy this month with all the holiday parties. Let's see what I did, this week alone. Monday was the SQL Server UG meeting. Tuesday was the company Christmas party. Wednesday was the VB.Net UG meeting. Thursday I met a friend from college for dinner (but if I hadn't been there I would have been at the Geek Dinner). Friday I went with friends from work to dinner and a hockey game. Saturday I went to Brendon's for a party. Sunday (tonight) I went to an old high school friend's for a party. I've had more food and more alcohol this week than I can shake a stick at. I don't exactly know what that saying means, I can shake a stick at an awful lot of stuff, but I think it still applies.

Next week I've got the Mobility UG presentation on Monday, dinner with my ex and other friends on Wednesday, drinks with a friend on Thursday, and Christmas with other friends all day on Saturday. And for New Years I might be driving all the way out to Dawsonville for a new-years party Brendon's in-laws are throwing. Wow - I'm a busy guy.

Somewhere in the middle of all this stuff I have to find the time to be a geek. I've got a tech book (as yet undecided which one) to read and I've got some presentations to plan. With all the partying and drinking, I might not get anything done!

PS - Does anyone remember the Atlanta Multimedia UG? I'm not sure if it was a programmer thing, but I think I recently met the founder. Just curious if anyone remembers it.

-- Matt Ranlett
MSN Spaces

General | User Groups

1/30/2005 2:50:17 PM (Eastern Standard Time, UTC-05:00)

Trackback

VB.Net SIG 2004 Wrap-up

Last night was the last VB.Net SIG meeting of the year. We’ve had a great time so far and I hope my involvement in the group continues to grow.

We lead off last night with a presentation from your truly on SharePoint Technologies. I had a slideshow AND demos this time. Paul Lockwood was kind enough to prepare a VPC for me with SharePoint Portal Server installed so I could show the group some of the great scalability and personalization services offered. I got some good questions and a generally positive response. I followed this up with a quick presentation on RSS, and Aggregators (or “What are Blogs and why you should care”). While most of the people in the room said they knew what blogs were, almost none of them had ever knowingly read one. Aside from Jim, Paul, Brendon, and myself – no one in the room had even heard of an aggregator like RSSBandit or SharpReader. I think everyone really perked up when they learned how cheap and easy it was to get started reading blogs. With the volume of information out there on personal blog spaces only increasing, it will be easy to get left behind if you’re not following along. At least keep your finger on the pulse of MS technology by reading Scoble!

After the excitement wore down and we took a break, Brendon presented the group with SQL Server Reporting Services. He kept his presentation deliberately short so we could proceed to the meat of the wrap-up session but he still managed to introduce practically everyone there to how easy and nice SQL Reporting Services really are. We saw some sample reports, some useful error reporting tools, the free web-based portal MS provides, and the report designer in Visual Studio. Once again, Paul stepped up with a VPC so we could practice installing RS (a generally quick but sometimes confusing process) but time constraints prevented us from seeing that.

After the two presentations, Jim took the floor and lead us in the discussion of what the meetings should look like in the future. For old times’ sake he dragged out a notebook with a list of topics originally thought of back in 2000 that still hadn’t been covered (and are still worth covering). We came up with some new topics; we flirted with the idea of a larger group project, and toyed with the idea of changing the meeting format a bit. No firm decisions were made, but people are thinking. We did manage to plan the first two meetings of the year out. The first meeting will mostly be a presentation of our favorite toys. I’ll give a quick book review and show off OneNote (on a Tablet). Jake will be presenting Visual Assist and John will be showing off some third party web controls which have some great client-side features. The second meeting will be Paul Lockwood giving us another look at nUnit – this time with a focus on the practical application of the technology. I’ll follow Paul with a quick review of some of the free tools offered by the incredible Mark Russinovitch of SysInternals.

-- Matt Ranlett

MSN Spaces

Coming up next! Sharepoint Services

1/30/2005 2:46:23 PM (Eastern Standard Time, UTC-05:00)

Trackback

At this point, anyone who reads this blog ought to know something about Sharepoint. If not, you need to catch up on some reading OR come out to the VB.Net Study Group meeting and listen to me present an introduction to Sharepoint Technologies (both Sharepoint Services and the Sharepoint Portal Server). This time I'll even have a Sharepoint Services Team Site to demo and for people to play around with. Paul Lockwood is doing me an enormous favor by bringing his machine in, and at my request he's built a Virtual PC with Sharepoint installed.

We're also having the year end wrap-up at the VB group where we'll planning out how we're going to do things next year. Come and shout out some topic ideas. We've preliminarily discussed the possibility of an ongoing project, of following through a book, and more of the same - generally disconnected topics. I know Jim would love to see some more member participation - he and I have jointly handled the presentations at the last two or three meetings. I'm not tired of it, but I'm running out of canned presentations to give. ;-)

I hope everyone who isn't already out of town for the holidays can make it.

-- Matt Ranlett

MSN Spaces

Atlanta MDF year end wrapup

1/30/2005 2:43:34 PM (Eastern Standard Time, UTC-05:00)

Trackback

Brendon and I met at the Atlanta MDF year end wrap up to contribute to the selection of next year's topics and speakers. We started the evening out with some socializing over great Chinese food, cheesecake (thanks, Dave R) and beer (thanks, Doug). We saw some of the regulars from other user group meetings - Keith and Harrell being the other winners of the “Most Masochistic Award”. Three lovely young ladies from Remington (a recruiting firm - ask Keith about them) came out to the group to learn a little more about technology and hand out business cards. I think that collectively they might just be old enough to drink, but they sure were cute. Erin, Diana, and Katie - thanks for coming out and I hope you learn something worthwhile as one of these user group meetings.

After we'd eaten our fill, the thirty or so of us got to shout out topic ideas for the board. Most of the list concentrated on SQL 2005, coming out this (Indian) summer. While most of the list seemed to focus on DBA-centric topics, I was pleased to see several developer issues get raised to the board. My personal contribution was debugging from Visual Studio 2005 into SQL Server 2005. Brendon shouted out (in a round-about way) “Developing for Performance” or “When not to use CLR queries”. I think we had something like 30 items on the board before we ran out of space. We also talked about sponsors and about potential speakers.

This is a great group and their high level of organization is what keeps them at this top notch level. The problem is that this high level of organization is taxing on the individual running the group, so Dave Fackler and Douglas McDowell have asked for some volunteers to help share the burden of planning the meetings. Brendon and I, always bucking for the limelight, have volunteered to shoulder some of the burden. We're hoping for a “leadership committee” of 5 or 6 people. With the additional help, Dave and Doug might not have to back down completely from running the group. I'd hate to see them go as they are a big reason for the success of this User Group.

Anyone who has some marginal interest in SQL Server (and if you are even a casual developer you should have some interest) should come out to some of these meetings. Tons of useful information flows through the group on presentation nights and the members are all very knowledgeable individuals. Come out, ask questions, eat free pizza, and learn a thing or two.

-- Matt Ranlett

MSN Space

C# Study Group meeting notes

1/30/2005 2:42:28 PM (Eastern Standard Time, UTC-05:00)

Trackback

Sorry I'm so late getting these posted:

I was a bit late to the meeting on Monday so I missed the very beginning of Rusty’s presentation. However, I didn’t seem to have missed much. Rusty presented a tool he developed to ease the installation of websites across multiple servers. While I have no experience with the problem of having to create multiple virtual directories, but I can easily see how that could quickly turn into a huge pain.

After showing us the tool he made, Rusty gave us a whirlwind tour of creating installer projects in visual studio. My only personal experience with creating install packages is with InstallShield. I thought InstallShield was pretty easy, but I didn’t like that I had to write my code in the installer script. I like that I can now use familiar C# or VB.

After Rusty sat down, Paul Lockwood gave us a presentation on Reporting Services. I’ve seen a few demos on the basics of the Reporting Services concepts before, but this is the first time I’ve seen a demo where a report was actually put together and deployed in front of my eyes. Kudos to Paul for a great job. If I ever work on RS, he should expect me to call him for help. Him or Keith. Or Brendon. In fact, it seems like I’m the only one with no Reporting Services experience around here.

-- Matt Ranlett

MSN Spaces

A day late and User Group Summary late

1/30/2005 2:38:09 PM (Eastern Standard Time, UTC-05:00)

Trackback

Ok so this was the first title when I was going to only be about a day late. Now that I am almost a week late I should have really called it a summary that is too late. Either way I wanted to say a couple good things about Mark Dunn and his presentation of BizTalk. So if you cannot tell, this is about the .NET user group meeting on Monday November 29^th.

It started out with a great presentation on how to help you get a job. Janet Turnure was a great speaker and maybe better than her husband Doug. (no offense Doug I still think you are a good speaker too and put some blogs up) Her presentation was followed by another great pair of speakers Mark and Mark. I bet right now you are making jokes in your head of Marky Mark and the funky bunch, but that is ok so am I. Actually the presentation was given by Mark Dunn, who brought along a co-pilot (Mark Berry), so it was a power packed evening. The topic was Biztalk which could be a blog in itself, but it was a great introduction to a new technology. They covered some material on setting up XSD’s and how you could use them in Biztalk, then showed us how easy it was to convert them with the built in tool of BizTalk. The showed how easy it is to do XSLT transformations on XML sets and how BizTalk has built in functions that can help you transform the data from one entity to the other.

I think someone invited some companies in the area to the presentation, because they had some pretty involved questions on the topic, so it was good to see those guys for the presentation. I wonder if we will see them again, you can probably guess what I think. Anyway, I hope that we will get part two of this presentation as it will actually take us into what Biztalk can do not just some of the setup. It seems like there is a good bit of interest in BizTalk in larger companies at the moment so we shall see where it goes from here.

-- Brendon Schwartz
MSN Spaces

VB.Net Study Group - my 4th presentation in a row here

1/30/2005 2:32:25 PM (Eastern Standard Time, UTC-05:00)

Trackback

In my continuing quest to bore people to death with demo-free slideshow presentations, I brought in a Microsoft slide deck about Visual Studio Team Services and the Team Foundation platform. I talked about the new Software Configuration Management (SCM) aspects of the Visual Studio experience. Things like integrated source code control, reporting, policy enforcement, etc. I had this same slideshow presented to me in a two hour presentation. I managed to squeeze half an hour off of this when I presented it (I ran a BIT long). But I had some interest, people who hadn't fallen asleep asked pertinent questions.

I'm looking into whether or not I am allowed to post the slideshow on the website. I'll post here (and mail the slide deck to Jim W.) if I get permission.

After I finished stealing an hour an a half from everyone's life, Jim got up to give us a presentation on debugging methods in .Net. He showed us that there can be more to debugging than breakpoints and MsgBox(). A great PowerPoint-free demonstration which included Test Driven's NUnit integration into the Visual Studio IDE.

Jim was waiting to trick me - he'd written a project with a user control where the user control couldn't be dragged onto the form. He expected me to bring my slideshow on a USB key and use his laptop. When I snuck in my Tablet PC, he was disappointed that I couldn't be forced to try to debug his issue. But that was offset by how cool I was, with my laptop with a screen you can WRITE on!

-- Matt Ranlett

1/30/2005 2:31:06 PM (Eastern Standard Time, UTC-05:00)

Trackback

Let the digital ink flow

After one VB User Group presentation and the Mobility Group presentation, I was tired of lugging my extremely portable workstation tower to give demonstrations. So, I now am the proud owner of a new PC. A Tablet PC!

Ok, so I've only been playing with it for about a day, and I'm pretty excited. This thing is sweet! I got the Averatec C3500 from MicroCenter. Looks nice, wireless, write on the screen (comes with OneNote pre-installed), all that jazz. I am going to play with the speech recognition next.

As cool as this thing is, I've spent abot 5 hours getting it set up. I had to install SP2 and other security updates. I put on some spyware protection and an antivirus program better than the 90 day trial of Norton AV. Seems like a lot of work to get a brand new machine really ready for prime time. If it seems like a lot of work for someone like me, a geeky computer professional, how must this seems to someone who is mostly computer illiterate?

Anyway, as I keep playing with this, I'll post more information.

Machine specs (for the real geeks)

12“ screen
AMD Athlon XP-M 2200 processor
512 Mb RAM
60 Gb hard drive
Built in DVD/CD-RW
Wireless 802.11g

-- Matt Ranlett

Taking Mobility to the VB people

1/30/2005 1:11:33 PM (Eastern Standard Time, UTC-05:00)

Trackback

Once again, the VB group was huge this week. I don't know what we're doing to keep participation as high as it is, but I hope it's all me! Ok, it's most likely nothing to do with me. Still, it's been one of the most consistent groups in town. We had a lot of regulars show up, a few new faces, and 2 interesting presentations. Well, maybe I only think they were both interesting because I gave one of them.

I gave my now trademark talk about Windows Mobility and the Compact Framework. I don't know how the group really felt about it, most of the questions were about limitations of the devices themselves rather than the Compact Framework. I brought in a SmartPhone from a developer kit I managed to acquire (thanks Doug!) and passed it around the room so people could get a feel for the thing. Once again, I had no demonstrations. But that's because I keep presenting the same material over and over again. I swear that I'm switching topics for my next presentation to this group (in 2 weeks).

After I was finished putting people to sleep, Jim Wooley gave us a great introduction to code generation. Anyone who has generated a strongly typed dataset from an XSD file has done code generation. In fact, anyone who uses a Windows form has used code generation. But those times, the tools did it for us with minimal intervention. What happens when we want to be able to generate larger portions of code. Surely something simple, like creating a data access object which represents a table with hundreds of properties can be automated via code generation? Sure it can, and in a variety of ways. Jim spent an hour conveying the code generation gospel according to Kathleen Dollard. Well, actually just chapter 1 of the gospel. Wicked cool about how much work you can save using known tools like CodeDom or XSLT. Then we got a look at CodeSmith - a tool which not only makes it easier to understand and use code generation - it's a tool which comes with the CSLA Framework from Rocky Lhotka built in! Now that's making things easy!

After the presentations we decided that noone hated hearing me talk so much that they didn't want me to do the next presentation, so I'm going to talk about Team Services. Another canned presentation, no demos. This is too easy. After that I'll be doing a presentation of all demos, but on the tools from SysInternals so I don't know what code to write yet. Something that mucks up the file system and registry, probably.

After all official Study Group business had been concluded, several of us went out for beers and boneless chicken wings at the near by Chili's. We talked about music and music technology (check out the most expensive speakers I've ever heard of - the $350,000 SH-833 from www.tmhaudio.com), MP3 players, noise cancellation, software factories, and corporate responsibilities in the face of the evaporating white collar job market.

Oh, and Brendon couldn't come because it was his mother's birthday. Happy Birthday, Brendon's Mom!

-- Matt Ranlett