2008
			2007
			2006
			2005
			2004
			2003

			2008
			2007
			2006
			2005
			2004
			2003

			2008
			2007
			2006
			2005
			2004
			2003
			2002

			2006
			2005
			2004

			2008
			2007
			2006
			2005
			2004

			2007
			2006
			2005
			2004
			2003

			2004
			2003
			2002
			2001
			2000
			1998
			1997
			1996
			1993

			2003
			2002

			2003
			2001

			2003
			2002
			2001

			2003
			2001

			Visual FoxPro 2001
			Visual FoxPro 2000
			Visual Studio 2000

			West Wind 2002
			Double Impact 2001
			FoxTeach 2001
			Jam sessions
			Technical Guidelines

			About
			Acronyms
			Contact information
			Troubleshooting
			Time zones
			Web Service
			Terms & Conditions
			Copyright

DevTeach offers a new breed of conferences. Sessions will include both presentation material and hands-on training. Traditional conferences had session leaders present material using a PowerPoint presentation, usually with some preprinted take away material. DevTeach sessions will add, whenever possible, hands-on training conjointly with the presentation. Attendees, equipped with their own laptop and wireless access card, will be able to try and test the concepts presented at the time of the presentation. This new concept is designed primarily for developers, but will not distract the others who may not be at that level. This conference will promote the latest Microsoft developer's tools.

Date:
Location:

Welcome to DevTeach Saturday	Magic trick Entertaining people during lunch	Carl Franklins Playing guitar
Craig Flannagan Welcome to DevTeach	Rick Strahl All the PRG methods

• Introduction
• Saturday, June 19
• Sunday, June 20
• Monday, June 21
• Tuesday, June 22
• Interview with Craig Flannagan (MSDN Canada)
• Picture archive

DevTeach 2004 started today with a couple pre-conferences and events you can read about it bellow, and will last until next Tuesday. I'll be covering much of it, and I hope to give you a fair overview of what the conference feels. I want to point to you that there are 8 tracks going on at the same time, so what I'll be talking about is just a little piece of the conference, and most probably the sessions I choose are not the ones you'll picked yourself. you can get the details outlook of the wide array of sessions at the DevTeach Official Schedule.

The conference is being held at the Le Centre Sheraton, located in downtown, and where I'm also staying, like most people attending the conference. The hotel is very nice, and there are some important buildings around here, like the Cathedral you can see in the Picture Archive.

People started arriving early in the morning for the pre-conferences, and they were kindly received by Jean-René Roy and Maryse who promptly proceeded with the registration, delivering also the official DevTeach bag with a good deal of goodies. The bag itself is a great notebook carrier bag with plenty of pockets everywhere (ideal geek-stuff!) and it had the conference block and pen, a CoDe Magazine, some promotional CDs and brochures, the attendee tag, and for the first lucky 100, a CD with two and a half years collection of the Universal Thread Magazine to be read offline.

Saturday, June 19

by Martín Salías

08:00 - Introduction to VB.NET and object oriented
Carl Franklin

This was the first pre-conference, and it was definitively very good. Carl Franklin speaks slowly, giving you time to follow him and he is extremely clear on his examples. This training was about explaining the very basics of .NET, but he wasn't less deep because of that.

He first explained types, references, basic inheritance, and casting.

Carl's Rules for casting

1. Casting does not COPY or CHANGE the object,
   nor CREATE new objects.

2. Casting changes the INTERFACE of the variable
   that accesses the object.

3. Casting ONLY works between related classes.

4. You can only cast as wide as the INTERFACE
   as the object being cast
   (this is not caught by the compiler, but just as runtime).

Public Class AnotherPerson
	Implements IPerson

Public Property Email() as String Implements IPerson.Email

Public Class Whatever
	Implements IPerson
	Implements ICustomer
	Implements IEmployee

Dim c as SortedList

Public Class CarlsTextBox
	Inherits System.Windows.Forms.TextBox
	
Private OriginalColor as System.Drawing.Color

Protected Overrides Sub OnEnter(ByVal e as System.EventArgs)
	OriginalColor = MyBase.BackColor
	MyBase.BackColor = System.Drawing.Color.Aqua
	MyBase.OnEnter(e)
End Sub

Protected Overrides Sub OnLeave(ByVal e as System.EventArgs)
	MyBase.BackColor = OriginalColor
	MyBase.OnLeave(e)
End Sub

EndClass

System.Runtime.InteropServices.Marshal.ReleaseComObjetc(_conn)

Other participants were Okest Hirniak from Ottawa (sorry if I spelled bad your name), Julia Lerman, from Vermont, our host, Jean-René Roy, from Montreal, Carol Roy, from Microsoft Canada, and several other User Group Leaders whose names I couldn't catch.

Sunday, June 20

by Martín Salías

Breakfast in the morning

I woke up very early in the morning (could I be nervous about doing my first official presentation in English?), and went down to the conference, where attendees were sharing breakfast.

I met there with Rock Legendre, from Montreal, and I introduce myself to Igor Lozhkin, whose session was about to cover. We recognized each other from the UT pictures, and this is something nice happening here all the time.

It was a great time to talk about our work and current projects, our experiences being people from very different part of the world, while munching some pastries and sipping coffee. Definitively, networking with peers is one of the great assets of these conferences, and DevTeach encourages it very much by having many get-together events during the days.

08:00 - Thin Client VFP/.NET Reporting against SQL Server
Igor Lozhkin

The purpose of this session was to present some of the techniques behind Arnica Software's WebReport product. I have to say that this is a very impressive product, being indeed an important component among their wide offerings.

Basically, the product features a server-side platform to design and consume reports. It is based in a thin-client solution which perfectly integrates in a portal environment. Indeed, it acts like a plug-in into Arnica WebPortal.

The products relies heavily in metadata stored in SQL Server or XML, and supports scripting and components written in VFP, C# or VB.NET (on the server side).

Something really neat in this model is that everything is done trough the browser, from designing the actual reports, with lots of different options and from many DataSources, to running them and getting them expressed in different format. No matter you are, the idea is that you can just log in with supervisory rights and maintain or expand any report.

Most of its functionality is also exposed as Web Services, so it plays nicely in a distributed environment, and in fact, the basic architecture is very distributed, supporting even clustering with node activation/deactivation, load balancing, etc, as all communication between components is HTTP based. Igor points out how important it is to keep this in mind to be able to expand without any limits.

Other important think that they adhere to is keeping the project running over standards only, like HTML, XHTML, CSS, XML and JavaScript (using VBScript out of the server side, for example, would be a big compatibility problem, as it would limit you to IE).

Another tenet of the arnica model is language independence, releasing the developers from the pressure to use any specific language to build additional components or write scripts. Igor talked a bit about the general strategy for collaboration between COM and .NET, and event with other platforms like J2EE and PHP using Web Services as a gateway.

Something else they specifically avoid are what he called non-scalable technologies, like ASP Sessions, cookies, DHTML, and other platform-dependent or proprietary mechanisms.

To maximize flexibility on the reporting generation, they use a 3-tiered approach, which involves a Report Source, meaning a source for the data coming via ODBC, ADO, XML, Active Directory, etc, right from the actual source or passing trough a script which is able to transform data generate a cursor with the needed information to report on.

Then there is a Report Filter layer which takes in charge of dealing with the final data manipulation, and finally, a Presentation layer in charge of constructing the actual Web pages.

Using all this techniques, they built a huge product capable to produce reporting either by printing, generating Excel, PDFs, emails, etc.

If you are interested in see their product in action, just go to www.arnicacorp.com/demo, register, and they'll provide you with a password to test-drive their implementation. It is worth seeing it, really. Even if you're not interested in buying the product, taking a look at this can get you many ideas.

09:30 - Comparing OOP in VFP to OOP in .NET (Basics)
Claudio Lassala

I already covered the first version of this session last year, but I attended to it again for two reasons:

The first one was to confirm how much has Claudio evolved as a speaker. He was already an awesome speaker in Brazil, but now he has now improved to a first-quality speaker, and his English is now perfect and fluent (I hope to get there at some point).

The second reason was more trivial and pragmatic. I have to do my presentation in this same room after him, so I preferred to be there instead of moving around.

But anyway, it was a pleasure to listen to him again. Claudio is a terrific teacher, able to mix fun, technical accuracy, and an appropriate timing. Moreover, he decided to cut his previous session in two parts, being that the first one covering the basics, and complement it with a second part for advanced topics.

In this first session, he covered Syntactical, Feature-related and Paradigmatic differences between CDP and .NET. This is invaluable information for the people just approaching .NET, and everyone there was able to perfectly grasp every concept, no matter how tough it sounds in the beginning.

He reviewed how procedural code becomes full OOP in .NET:

VFP: 
   dDate = Date()
   cName2 = Alltrim(cName)

.NET:
   dDate = Date.Now
   cName2 = cName.Trim()

Visual FoxPro
   Define Class Customer as Custom

   EndDefine

C#
   public class Customer
   {
   }

VB .NET
   Public Class Customer

   End Class

Visual FoxPro
   Local oBiz as Customer
   oBiz = CreateObject("Customer") 

C#
   Customer oBiz;
   oBiz = new Customer();
or
   Customer oBiz = new Customer();

VB .NET
   Dim oBiz As Customer = New Customer()

This is the URL: http://workspaces.gotdotnet.com/TierAdapter

Thanks to my good friend Claudio Lassala, we have at least a short report to include here:

"I had two reasons to attend to Martín's session: one reason was because I'd be presenting a session on the same topic at this same conference, but with a different approach, and I wanted to make sure our talks wouldn't overlap. The other reason was because I knew that was his first talk held in English, and I know how hard that is (yeah, I've been there before recently <s>), so I wanted to be around and give him any piece of advice that might have crossed my mind and that I thought it could be helpful for him on his next talks.

Martín has delivered a good presentation. The content was good, and I also know how hard it is to present such a hard topic on such a short session. I definitely recommend people to go after Martín's open source framework, and whatever articles he happens to publish about it, because that's a great way for VFP developers to learn N-Tier development with a framework that was built originally just as an example and then has evolved overtime into a framework that people can even use in a production environment."

Thanks for the notes and the support, Claudio!

13:30 - Reporting System Enhancements in Europa
Doug Hennig

This session had, of course, a great impact in al attendees. Just after a short introduction, Doug (my favorite speaker, by the way) showed some little good demos to calm everyone's appetite.

Then he started to enter in more detail in each of the new features, presenting and outline, and pointing out that this first session was fairly general, and there would be two more about extending reporting at both design and runtime.

The first explanation was about the new reporting goals:

• Protect investment in existing FRXs
• Open architecture
• Improve the UI
• New features: protection, design-time captions, absolute positioning, DataEnvironment handling, and international support

Some of the improvements made to cover these goals at the User Interface level were the use of fewer and better dialogs in the editor, using a tabbed interface and getting all possibly related attributes in each dialog, as the field properties or report properties dialogs, for example.

Something very important is that those dialogs are not internal VFP features, but xBase code whose source is provided and can be changed. Other UI improvements are seeing on the menus, toolbars and shortcuts menúes also, which are more consistent and powerful.

A functional great new feature for the people letting their users edit their own reports is protection. Basically it gives the developer the ability to select what things the user can do to elements, bands, and the whole report itself when running in protected mode (by using the new protected keyword in the modify report command).

Several other new things like design time captions, absolute positioning, vastly improved data environment handling and better international support were presented, and then a very popular feature was fully explained: multiple detail bands.

This is an extremely helpful thing, and Doug showed some very clever uses of that, including a report over Sales Orders grouped by Employee, but where each employee's order count and total amount are show above the group, in the group header. Also, using the same trick, he could add the percentage of the employee total sales which each order represents. All this, of course, was made without a single line of code, using just report properties and a couple variables.

Then he briefly explained the new rendering engine, based on GDI+, which allows for many interesting things. I'll cover this and the remaining topics in more detail later, after Doug Hennig's sessions on extending the reporting system.

15:00 - Exchanging Data Between VB.NET and Visual FoxPro 8
Beth Massi

This session started with a small problem, as the overhead projector was not working at all, but Beth overcome the situation very good by starting with a paper board and explaining her stuff by drawing diagrams and talking about the concepts. Later on the projector got fixed and everything went on very good.

Something interesting to keep in mind is that she's working on a project to bring the Codebook framework to .NET, so this is something we should definitively try to be up-to-date.

The basic points about this sessions was why Web Services are a good idea to pass data around, how to communicate VFP and .NET, including the basics to work with Web Services from both platforms, how to deal with hierarchical data, and specially how to make updates in such a model.

I started to feel comfortable by noting that many of us were sharing the same ideas about how distributed architectures should work and what are the best practices around (more on that in other sessions).

She explained why Web Services are a great solution for huge systems that have to share data with other systems and clients, even in disparate platforms, and overall, why they are much better than COM or DCOM. Also, Web Services are easier to access from rich clients to browsers and smart devices, support well disconnected scenarios and above all, they work over HTTP, making them easy to deploy across the Internet.

Can't skip pointing out how nice Beth's slides are. Everyone liked them, and I guess more than one though about "reusing" them.

After showing the diagrams, she described the basics of SOAP, giving an overview of what a SOAP packet looks like, and how it is formed by a header and body.

Then she presented the several tools available in VFP to work with Web Services, including the Toolbox (to register and use Web Services), the Task Pane (to register, publish, explore and test them), and the use of the WSHandler class on the Fox Foundation Classes (FFC) and the Web Service Builder. Another chance mentioned is to just manually use the SOAP Toolkit, which is harder, but allows for higher level of control.

Then she quickly build the classic Hello World demo on a VFP Web Service, and to extend to a more useful example, she first talked a little about XML as a universal data access mechanism.

She highlighted that XML can be marshaled across tiers and easily handled with any standard XML parser in any platform. And now, ADO.NET datasets makes working with XML data even easier, automatically serializing tables and providing support for different clients like WinForms, WebForms, Mobile Controls, or VFP 8 and above trough the XmlAdapter class.

She presented a demo of a VB.NET Web service over the well-known Northwind database from the ASP.NET Sample Page and from the VFP Task Pane, and then she explained the basics about retrieving datasets using ADO.NET:

' Create your connection
Dim MyConn As New SqlConnection(strConnectionString)
' Create your command and assign it your connection
Dim MyCmd As New SqlCommand("SELECT * FROM TABLE", MyConn)
' Create your Data Adapter and assign it your command
Dim MyDa As New SqlDataAdapter(MyCmd)
' Fill your DataSet using the Data Adapter
Dim MyDataset As New DataSet
MyDa.Fill(MyDataset)

oWSProxy = CREATEOBJECT("MSSOAP.SoapClient30")
oWSProxy.MSSoapInit("http://webservice/service.asmx?wsdl", "ServiceName", "ServicePort")

oXMLDOM = oWSProxy.GetMyData()
oSchema = oXMLDOM.item(0)
oData = oXMLDOM.item(1)

XMLAdapter.Attach(oData, oSchema)

FOR iLoop = 1 TO XMLAdapter.Tables.Count
   XMLAdapter.Tables.Item(iLoop).ToCursor()
NEXT

LOCAL lcXML as String
oXMLAdapter.IsDiffgram = .T. 
lIncludeBefore = .T. 
lChangesOnly = .T. 
lIsFile = .F. 
cSchemaLocation = "" && inline schema

oXMLAdapter.ToXML("lcXML",;
  cSchemaLocation,lIsFile,;
  lIncludeBefore,lChangesOnly)

In conclusion, a very good session, that matched very good with the topics many of us were presenting. I think distributed applications are the main topic in most the architectural presentations, definitively.

16:30 - C# Language and Tools: What's New in Whidbey
Kevin McNeish

Kevin sessions are always funny no matter how hard the topic is. Indeed, he started by playing a short humorous clip to make people relax after a full day of information overloading.

One of the first things he pointed out is the fact that the official name for what we call now Whidbey will be Visual Studio 2005, without the .NET moniker anymore. It seems that the good idea of take the .NET brand away from other products finally got into the developers tools.

Then he started to tour the audience around some of the new additions to the upcoming version of Visual Studio. Of course, being an early preview, some things don't work perfectly yet (although it didn't blow at any time during this session) and some others may change over time.

He first went to the IDE improvements, then to the language enhancements.

One welcome addition is a series of Refactoring features. I think there are a few details to improve there yet, but there is still plenty of time to make suggestions and wishes to the VS and C# teams.

Some of the things you can do are Rename a Class or Method throughout a full solution (and here I think the scope should be expanded to many solutions, to deal with framework projects), and in the same fashion, change parameters, parameter types, and so on. The cool thing is that Visual Studio shows you a tree with all the components that it needs to update, and you can navigate to them and see highlighted code in a before-and-after way.

Other features allow you to extract methods from other portions of code, helping to eliminate long routines rationalizing them; encapsulate fields by using properties and making all the changes to any previous access code, and other useful things that can improve your code, but many times one just leave as is to avoid the task of rechecking and updating all the code.

There is also an option to refactoring an abstract class to an interface, which, as noted by Kevin, gives you the best of both worlds, because you can use it by either subclassing it or by implementing the Interface (allowing also for multiple interface inheritance).

Other handy feature added to C# is code expansion, which level the field with some usability stuff VB.Net always had. There is one of the code expansion things that alone could make a great difference, and it is the ability to use a class, and if the namespace is not previously declared, a smart tag (like the ones in Office XP and 2003) let you choose between adding the using clause at the top of the source file, or add the full namespace in this specific line. It isn't really cool?

Productivity is also increased by little details like curly braces being opened when you type a class definition, and if, else or using block, and yellow boxes appears letting you enter the names, conditions, etc. The same happen with properties. Now the get and set blocks, can be automatically expanded much like VB.Net always did.

More improvements have made into the debugger, letting you navigate xml and datasets in tabular format instead of plain strings or just having to expand node by node.

Entering the space of language enhancements, one of the most important things perhaps is Generics. Basically, while in the past you have to choose between strongly-typed arrays which you can redimension, or ArrayList, which can grow but are not strongly-typed at all, you now have generics. These are like an array list but with a strong type declared, and this doesn't just your code safer, but faster, as by having a single type, no casting needs to be made, nor any kind of boxing/unboxing operation.

Here is an example:

public class Generics
{
   List IntegerList = new List();
   List StringList = new List();

   public Generics()
   {
      // Items are added to strongly typed collections
      IntegerList.Add(1);
      StringList.Add("Test");
      
      // No cast is required when retrieving values
      int i = IntegerList[0];
      string s = StringList[0];
   }
}

btnTest.Click += delegate {
 listBox.Items.Add(textBox.Text); };  

One interesting thing in the next version of the framework are partial classes. The idea is that you can break a class definition among several source files. You just declare and write different methods wherever you want. Visual Studio uses this itself to separate the code it automatically generates for UI controls, for example, from the code you write. This way, it's less likely you mess things up.

I have mixed feelings about that. It can be useful for some purpose, but abusing this feature can drive to maintenance nightmares. Handle with care and be sure to ask your doctor about it.

Another feature that can be very useful but can derive in terrible headaches is Nullable types. Basically, you can now define any member to be of some type and nullable. So you can have a Boolean being either True, False, or null. Same with an integer or any other type. As someone said in a movie: with great power comes great responsibility…

Finally, he showed the new ability to define static classes. You already can have a class with all its methods declared as static, but it leaves room to some problems, so if you don't want it to have non-static members, this is the solution.

In conclusion, a great overview of a great language getting even better, and receiving some well deserved editing help.

Monday, June 21

by Martín Salías

9:30 - Distributed Application Architectures in .NET and Visual FoxPro
Beth Massi

As I commented in yesterday's report, there are a few sessions in the conference around the same topic of distributed and tiered applications, bringing different approaches and conceptual overviews, but all of them agreeing in a consistent paradigm. This was another one of them.

Beth started by stating that distributed apps, no matter which language or platform, are based on a model of user interface tier, business logic tier, and data access tier.

She also mentioned the pros and cons of this model. The cons: slower performance for small groups of users, taking longer to write and test, and being harder to deploy. The pros: scalability, flexibility, easiness to add several UIs, system integration, and data maintenance. I think this is generally fair, although many of the cons could go away once you have a proper framework running and a streamlined methodology.

This architecture makes you also take some design choices like agreeing on a common contract (methods, interfaces, data schemas, etc), access mechanisms (DCOM, .NET Remoting, messages only trough Web Services or other).

She did a brief explanation on those access means, pointing some of the problems with COM/DCOM. She did a funny story about having to reboot a server in a 24/7 setting due to memory leaks, showing some comedy skills. She makes her sessions easy to follow by moving around and shooting little jokes many times.

Then she did an overview over Remoting, pointing at its advantages, while still keeping some of the DCOM ideas behind, and finally arrived to a quick explanation about the scenarios in which Enterprise Services (COM+ for .NET) is required.

And she finally arrived to Web Services, the preferred communication today. She made some detailed explanation about its advantages over DCOM and Remoting, too long to cover here, but the main points are that they are available on any important platform to .NET, Java and even VFP, they are better to support smart clients en do B2B communication, they use HTTP so they are easier to connect, and so on.

Then she made some explanations and demos using VFP and .NET complementing the ones she did in yesterday's session. This one was more conceptual and went to the alternatives and benefits of several approaches, and gave ample information about all of them. Both session were very good and made very clear the main issues and best practices about this topic.

11:00 - Using Visual FoxPro to call .Net Web Services for Data Access
Rick Strahl

What can I tell you about this session? For one, it was really great. Beside that, it confirmed my vision that we all are talking basically the same here, but it is good because every speaker is adding more and more information around the same strategies and practices, and people are indeed taking advantage of that, and getting a deeper understanding of what the new world of services oriented architecture is about, why most components have to be stateless and support asynchronous calls, and why we're not in Kansas anymore.

I wouldn't enter in great detail about the session because, as usual, you can go to the amazing collection of Rick's white papers at http://www.west-wind.com/Articles.asp and read about most of the topics presented here.

All in all, many of the points Rick targeted were similar to the ones Beth talked about in the previous session, but this time, he used some alternative approaches and went more to practical examples and -as usual- a few clever utilities he developed to make things easier, and which you can get right from his site, in most cases as freeware.

He basically showed some examples about building a Web Service in .NET and calling it from VFP using the SOAP Toolkit, and showed some of the good and the bad features. Some of the bad ones are lack of Intellisense if you don't get to the chore of registering the wsdl on Intellisense every time the service changes, and some excess of data conversion if you don't make things in the right way.

To make it good, the best way to return data is to avoid returning XML strings that produce a lot of overload on SOAP packets because they need to be encoded and decoded, and get in and out of DOM objects. Instead, you have to make the Web Service methods to return datasets right away, and what the SOAP Toolkit gets to you is an XML DOM Node list. This is something quite easy to handle once you know how, but as doing it every time can become a bit heavy, Rick just wrote a class to deal with this easily.

And in fact, he implemented several tools to abstract all that process in the same way a business object class abstracts you from the details of data access. Basically, the class calls the Web Service and returns to you cursors. Nothing else to do. Also, writing this once he had the chance to put there most exception handling and other basic stuff.

Something cool about using ASP.Net Web Services, even from Visual FoxPro, is how easy is to trace them. He set a breakpoint, went to VFP, made the call, and the debugger popped up stopped on the breakpoint.

He then went to the updating part, using diffgrams and sending them back to the Web Service to be used with a dataset to update the data on its corresponding layer. But you should know this at this point.

Something very important he noticed is that you have to think different about the functional design of your client application. You can't just deal with data entry the same way as you did with local data. Updates should be scarce and rapid, and you can't pass too much data over the wire, so you have to design to minimize all this.

To make things really easier, he presented a tool to create wrapper classes around web services, providing abstraction, Intellisense, and much more. Look for them at the West Wind site.

Tips over the session:

• Remember to always set the UTF8encoded property on your XmlAdapter to TRUE when dealing with datasets. I have this property set in my base XmlAdapter subclass, by the way.

• Want to know what's going by the HTTP pipe when you use Web Services? Take a look at Fiddler Http Debugging Proxy (www.bayden.com/fiddler/help/)

13:30 - Extending the VFP 9 Reporting System, Part I: Design-Time
Doug Hennig

In this session Doug gave the audience a deep inside in the inner workings of the new report engine from the designer perspective. Here are some of the highlights, although you'll got plenty of information about this later in different magazines and community sites, so I'll not cover all he did in his presentation. It is just too much.

The main goals the VFP Team had when revamping the report engine were: simplifying and improving the UI to avoid the current bunch of clicking and modal-dialog surfing we are accustomed to; adding new features (we'll see many of them), and make the whole thing very extendable.

First of all, they added a lot of design-time events to the report designer, so the ability to hook on them and customized it all has explosive consequences. The new _REPORTBUILDER variable points to an application (the one shipped is called ReportBuilder.app) which takes care of handling most of the design-time events, and implements many of the additional features in plain xBase code and VFP forms as dialogs.

Of course, you can write your own report builder application, or you can just use it and extend it trough a series of provided mechanisms. This would be, most probably, the preferred way, as it still leaves you plenty of room to handle almost every aspect of the designing process.

In this way, you create your own handlers for different events, which you can register by running ReportBuilder.app from the command window. When you do it, an option dialog appears with several other uses.

The things you can do at design time by using handlers are almost limitless. Doug showed a few examples as getting a basic report from a template each time a new report is created, and then even better, showing a dialog to choose what kind of template you prefer. But this is not like just copying an existing report, renaming and editing it. This used to left room for a user or developer to skip picking a template. This is automatically made when creating a new report.

You can do other things like preventing or controlling access to the data environment, creating your custom dialogs for fields (for example, letting the user pick them from a data dictionary or something like that), and lots of other cools stuff that VFP developers will quickly figure out in the future.

15:00 - Using VFP's SQL Commands in Europa
Tamar Granor

This session could have being dedicated to Joe Celko, a widely known SQL specialist who used to wrote the "SQL for smarties" column on DBMS Magazine years ago, an has a few books about the topic. And this is because much of the great enhancements on SQL syntax on VFP 9 have not immediately obvious examples.

Basically, one of the general topics around the whole SQL engine was take away most existing limits, while getting the semantics really closer to the SQL Server one. I know that most of these improvements are the work of Aleksey Tsingauz from the VFP Team, to whom I'm always in debt for his invaluable help on the Universal Thread forum. Tamar also expressed her acknowledgement to Aleksey during the session.

It would be difficult to resume the explanation behind every one of Tamar's examples, so I'll copy here most of them and let you appreciate the SQL power on VFP 9.

Nested subqueries:

SELECT iID, cFirst, cLast ;
  FROM Employee ;
  WHERE iID NOT IN (SELECT iSupervisor FROM Employee)

SELECT Orders.Order_ID, Customer.Company_Name as Cust_Name, ;
       Shippers.Company_Name AS Ship_Name, Orders.Order_Date ;
  FROM Orders ;
    JOIN Customer ;
      ON Orders.Customer_ID = Customer.Customer_ID ;
    JOIN Shippers ;
      ON Orders.Shipper_ID = shippers.Shipper_ID ;
  WHERE Orders.Order_Date = ;
    (SELECT MAX(Order_Date) ;
       FROM Orders Ord WHERE Orders.Customer_ID=Ord.Customer_ID );
  ORDER BY Cust_Name ;
  INTO CURSOR MostRecentOrders

SELECT Customer.Customer_ID, Customer.Company_Name, ;
       Customer.Address, Customer.City, Customer.Region, ;
       Customer.Postal_Code, Customer.Phone, Customer.Fax, ;
       (SELECT SUM(quantity*unit_price) ;
          FROM Orders ;
            JOIN Order_Line_Items;
              ON Orders.Order_ID = Order_Line_Items.Order_ID ;
          WHERE BETWEEN(Order_Date,DATE(m.nYear,1,1),DATE(m.nYear,12,31)) ;
            AND Customer.Customer_ID=Orders.Customer_ID ) as YTotal ;
  FROM Customer ;
  INTO CURSOR CustomerTotal

UPDATE SalesByProduct ;
  SET UnitsSold = (;
    SELECT CAST(NVL(SUM(quantity),0) AS N(12)) ;
      FROM Order_Line_Items ;
        JOIN Orders ;
          ON Order_Line_Items.Order_ID = Orders.Order_ID ;
      WHERE MONTH(Order_Date) = nMonth AND YEAR(Order_Date) = nYear;
        AND Order_Line_Items.Product_ID = SalesByProduct.Product_ID)

SELECT cFirst, cLast ;
  FROM Person ;
  WHERE iID in ;
  (SELECT TOP 20 iPersonFK ;
    FROM PersonToItem ;
    ORDER BY dEffective) ;
  INTO CURSOR OldestContacts

Interview with Craig Flannagan (MSDN Canada)

by Martín Salías

Craig Flannagan

During the DevTeach 2004 Conference at Montreal, we have the chance to interview Craig Flannagan, Senior Marketing Manager for MSDN Canada.

The MSDN booth was a great success at this conference and everybody is very happy with the SWAG gifts, specially the technical previews and Dev Days information, things that are not so widely available and every developer value, and of course the books, also.

Universal Thread: Hello, Craig. Can you tell us who are you? How did you start in this business?

Craig: I've been in technology based marketing for almost six years now; my focus has been on the developer space for the last 3 years. I joined Microsoft in February, 2003 as the MSDN Program Manager.

What's exactly your job right now at MSDN Canada? What are the main projects your division is working on (at least the ones you can disclose <s>)?

My role at Microsoft Canada is that of MSDN Program. I am responsible for the delivery of our developer community programs, which include the MSDN Canada website (msdn.microsoft.ca) our MSDN Flash newsletter (sign up at msdn.microsoft.ca/flash), all of our events including MSDN deep dives and supporting other great community events, including DevTeach. Also, there is a lot we are doing for developers, so forgive me if I go on too long! Of course we support our MSDN User Groups, and our community outreach programs like Regional Directors (check out msdn.microsoft.ca/rd) and MVPs (Most Valuable Professionals - www.microsoft.com/mvp)

As for big projects - we are working on two great events to take place in the fall, they are called devcan - watch msdn.microsoft.ca/devcan and www.devcan.ca for more details soon.

I know you worked closely with Fede Raggi, whom I know since many years ago, on the Five Star development program. Can you elaborate on that?

Working with people like Federico is one of the best things about working for Microsoft; he's very good at what he does! He is also very in tune with the developer community. We are working together on bringing the five star program to Canada. It's online learning that will help developers at any stage along their learning path - from those who are just getting into development to those who are becoming certified application or solution developers (MCAD or MCSD). You'll have the whole scoop as we get closer to bringing this live.

How are development communities going in Canada in general? What are the main cities where the activity is concentrated?

There are strong developer communities all across Canada! You can see the evidence of that from our strong user group network. There are .NET focused user groups from St. John's, Newfoundland to Victoria, British Columbia - 25 in total now.

What about market penetration of .NET here? Are you experiencing the same adoption rate than in the US, or do see some particular differences?

In Canada we see a slightly faster adoption rate than in the US primarily driven by mid and small business. Canada has a vibrant mid and small biz landscape and with limited technology budget but similar requirements: fastest time to market and lower total cost of ownership, and thus .NET has proven to be the best option.

We had a meeting with user group leaders a couple years ago and they are doing great, but that seems to have some common problems about communication, financing, getting speakers involved, and so on. What are your strategy regarding user groups in general? How do you coordinate or separate task with INETA?

The user group program is growing very quickly in Canada. INETA is a great organization; they provide great support and great speakers to user groups. We are coordinating our efforts with INETA to provide as much support as we can to user groups. We have a very close relationship with our user group leaders, and are constantly taking feedback on how best to support them. The feedback we've heard is just as you have stated - User Groups from time to time need support in four different areas: content to speak about, people to present it, members to present to and a place to have a meeting. We have set up a Canadian MSDN User Group SharePoint portal which allows groups to request speakers, tell us when their meetings are, and collaborate with other leaders across Canada. We will also continue to run cross-Canada user group tours.

The bottom line is there is a lot of support out there for Canadian developers and they should join a user group near them - visit msdn.microsoft.ca/usergroup to learn more about the Canadian MSDN User Groups and www.ineta.org to see the World wide .NET User Group program.

Finally, of course, I have to ask you about your opinion about DevTeach? Did you attend any sessions? What do you think about the organization in general? What do you think it can be improved for next year?

Microsoft is a proud sponsor of DevTeach. I think it's amazing to see the power of the community - an event run by developers, for developers. Jean-Rene Roy is an amazing asset to the community! DevTeach draws some of the best speakers in the world; I see this event getting bigger and better as the years go on.

There is anything else in special that you want to tell the community?

If I could make one recommendation to the Canadian developer community, it would be to get involved! Join a user group in your area, participate in online forums, seek out your regional director (visit msdn.microsoft.ca/rd). Anyone who is interested in getting more involved in the community can visit msdn.microsoft.ca/community to find out how!

Thanks a lot for an interesting interview, Craig.

Martin Salias, Microsoft South Cone   Martin Salias (Buenos Aires, Argentina) is currently acting as an Enterprise Architect for Microsoft South Cone. He has 25 years in the software industry working with several different platforms and languages, working for organizations ranging from the United Nations to Microsoft Consulting Services. He is Editor in Chief for Level Extreme .NET Magazine, a member of the Agile Alliance, and a Microsoft MVP.