Sunday, June 15

Andrew MacNeill's Advisor JumpStart: Web Services

by Christopher Bohling

According to Andrew MacNeill, web services are very much like FoxPro functions. In fact, they can be VFP functions, as long as those functions are wrapped up in a COM object, the COM object is published to a Web site along with WSDL and WSML files, and the SOAP client (known as the WHOLEBODYWASH client in Southern California) is installed on the web service "consumer." In addition, Web Services messages are carried in XML over HTML on the Internet (which itself uses TCP/IP as its network transport mechanism.

This is not the end to what Andrew described as "acronym hell." XML files use the DOM, XML Document Model. The DOM can be used in combination with schemas internal to XML documents to find just what the document contains. According to Andrew, these properties (including collections) and methods are the keys to interpreting schemas and the XML data they define:

• HasChildNodes
• ChildNodes.Length
  • ChildNodes.Item(0)
  • NodeName
  • NodeType
  • NodeValue/NodeTypedValue
• Attributes.Length
• SelectNodes()

For Andrew, learning the ins and outs of the XML DOM is of paramount importance in becoming proficient with Web Services. He also made other important points:

• VFP 8 is best for developing Web Services, and versions 6 and 7 can still consume those services.
• Security is often implemented with encryption keys that are passed to the Web Service along with the other input parameters.
• The keys would have to be passed every time, as Web Services are stateless.
• Even if you are not able to deploy a Web Service, plain web pages can still be good sources of information.
• The UDDI (a business-to-business integration effort using XML) and xMethods web pages offer examples of Web Service implementations, but the field as a whole.

Andrew closed on a positive note, paraphrased here: The most important thing is to learn the XML DOM.

When asked about the session, Erik Trutner of Oakland, California, said, "As a novice concerning Web Services I found Andrew’s presentation to be very informative and undoubtedly will be a great basis for my future work in Web development."

Ted Roche's Advisor JumpStart: Visual FoxPro Development

by Christopher Bohling

This reporter rushed to cover this session when it became clear that a group of other speakers had formed a baked goods terrorist group known as Al Cake-a that was intent on making Roche celebrate his birthday. After receiving his cake joyfully, Roche spent the last two minutes of his session presenting an exhaustive analysis of project management. (Parts of this story are made up.)

Rod Paddock's Advisor JumpStart: .NET for VFP Developers

by Christopher Bohling

Having established himself as a leader in the VFP realm, Rod Paddock is doing more work in .Net, including presentations. Paddock made a half-day seminar at the Essential Fox conference in Kansas City in April. (Note: my employing company sponsors that conference.) I had to miss that seminar because a client of mine had an issue that turned out to take four hours to resolve. Fortunately, I got to see Rod’s two hour presentation here at DevCon.

Those interested in .Net should also be sure to read Evan’s report on Kevin McNeish’s presentation, below.

Rod thinks that there are a lot of advantages to using .NET and the Visual Studio.NET editor. The error checking built into the VS.NET compiler is better, in part because variables are strongly typed. Debugging can go a step further than any VFP developer might try. Visual Studio can “attach” to a running a executable, even remotely, and monitor the executing code.

VS.NET contains more default controls, like the calendar control and a slider. Fewer controls need to be dug out of the depths of the Windows system.

Installation of the .NET runtime will enable a client machine for what is pretty much a copy and paste install of the DLLs created by the .NET compiler.

While FoxPro contains a mix of objects with “unaware” constructs like memory variables, in .NET everything is an object. This means that even variables contain their own properties and methods. Assuming that y is a numeric variable for which you want a character equivalent, instead of coding x = STR(y) in the VFP style, a .NET developer could use x = y.ToString. More methods could be added to the list, as well, such as a trim function. (For example, x = y.ToString.Trim. Best of all, each one of the available methods will appear in an Intellisense list.

More functions can be made available by adding a project “reference” to a solution. Many references can be retrieved from the Global Assembly Cache (GAC), but they can also be from a custom project or third party tool.

Just before break we learned that Rod is engaged to Jessica Wills. (See the picture archive for a photo of them together.)

After break, Rod demonstrated how easy it was to build Web forms with VS.NET with very little code. Controls can be dragged and dropped onto Web forms just like Windows forms. VS.NET will even debug Web forms just like Windows forms.

Though skeptical of new technology, Rod said that after using Web Services he decided, “I will never build another application again that uses data on the Internet without using a Web Service.” .NET enables Web Services by allowing methods to be tagged as “Web Methods.” These methods are exposed to the Internet.

Finally, Rod discussed ADO.NET and data sets. Those attending will get access to utilities that he routinely uses in working with data set objects.

Cathy Pountney's Advisor JumpStart: Visual FoxPro Report Writer

by Christopher Bohling

Cathy Pountney's credentials as the leading VFP report guru include a book on the subject (edited by Dave Aring, my coworker and friend), numerous published articles, a long track record of presentations, and six months working with the Fox team at Microsoft.

Cathy first reviewed the report wizard. Two of the most pertinent points were 1. the wizard can create an index without you knowing it and 2. the RptStyle table is the place to add customized styles. But, if you do create a new style, base it on an existing one. VFP expects styles to contain certain items.

After the wizard, she shifted attention to the report designer. The best news from this discussion was that VFP 8.0 includes a Reports tab on the Options form where report defaults can be set. There were several other items discussed that it might be useful to read about in Cathy's book. However, if you know the maximum number of bands a report can have, you are at least 0.03% there.

Then came the discussion of data sources, data sessions, and the data environment. Cathy pointed out that data entry systems work best with normalized data, whereas reports are easier with denormalized data. Reports lose this fight and there are inevitable questions about how to prepare data for reporting. Two tips worthy of considering are to set the AutoOpen and AutoClose properties of cursors in the data environment to false. This way a cursor can be used during development that will not need to exist under the same name at runtime. Also, the BeforeOpenTables and OpenTables methods can be used to manipulate data.

The BeforeOpenTables event can serve as the location of code to change the relative paths that the data environment adds for tables.

Cathy also discussed report objects, including controls, report variables, running reports, and distributing reports. Two points to keep in mind are to always remove printer information from the .FRX file (which is done with a menu choice in VFP 8) and that the "Release After Reports" option does not work for report variables.

She added a handy tip for selecting labels easily for editing: highlight the label and type Ctrl+E.

There was much more to this session. If you want to run VFP reports, and you have not checked out Cathy's work, it would be well worth your while.

Chris Bohling, Myers and Stauffer LC   My experience with database and application development stretches back into the 1980s, when dBase II was on the bleeding edge. In addition to Visual FoxPro®, my current set of development tools includes Visual Basic® .NET, C#, Microsoft® SQL Server™, Windows Installer, and several other applications and utilities. I am a Microsoft Certified Professional in Visual FoxPro® and Visual Basic® .NET. My experience includes full lifecycle development and maintenance work, as a team member and individually, on projects for companies in the insurance, manufacturing, construction, research, non-profit, and cleaning service industries. I spend a lot of my free time reading about software development, project management, and design patterns. I live in Shawnee, Kansas with my wife Claire and my daughter Melanie.

Kevin McNeish's Advisor JumpStart: .NET Development

by Evan R. Pauley

8:00 am

It’s too early for late-night developers like myself.  My heart hasn’t starting beating yet.

Nevertheless, here I am.  I’ve had my first caffeine injection (I take my caffeine cold, so it’s Vanilla Coke instead of Starbucks), and I’m in the first "JumpStart" pre-conference session of the day, the session on .NET development being taught by Kevin McNeish of Oak Leaf Enterprises in Charlottesville, VA.  Kevin is well-known in the VFP world as the architect of the Mere Mortals development framework, and has also written an excellent book on UML modeling.  The session has about 20 attendees.

I’m not personally knowledgeable in .NET, since most of my clients currently don’t require this knowledge.  All my further comments will, therefore, contain my personal "spin" on Kevin’s comments.

Kevin has tailored his presentation, obviously, to VFP developers moving to the .NET initiative.  One of the major advantages of .NET is the single learning curve for developing both desktop and Web applications (and also for handheld or mobile devices, if necessary).  There’s also no interoperability layer, such as COM, between the different .NET languages, which eases compatibility issues between modules written in these languages.  .NET handles the creation, release and "garbage collection" of objects considerably more efficiently than VFP, which greatly reduces application "memory leaks" and applications that run slower as they get older.

Kevin also touched early on the fact (well known to everyone here) that Microsoft is strongly marketing .NET to their entire development community and has anointed .NET as "the future of software development at Microsoft".  This means that persons with both VFP and .NET skill sets are an extremely HOT property right now.  Kevin stressed that while VFP is not going away ANYTIME soon, and VFP still reigns supreme when handling large amounts of local data, the market for VFP is definitely diminishing.  This doesn’t mean VFP is completely out of the mix, however; VFP COM components can easily be called by .NET applications.

1. the Common Language Runtime, or CLR, which is similar to the VFP runtime;
2. the base classes, which provide the core for the application’s "plumbing";
3. the presentation classes, which provide the visual capabilities for ASP.NET, Windows Forms and mobile devices (these are MUCH larger than VFP’s base classes, numbering about two thousand)

There are three primary .NET languages: C# (known as ‘C-sharp’), VB.NET and C++.  C# was the language used to author the .NET framework itself.  Since C# is a new language specifically designed for .NET, the C# team is focused entirely on advanced OOP and *performance*.  If you’re not already a VB programmer, Kevin believes that the migration path for VFP developers to C# will be much smoother than the other languages.  For Java developers, C# is very similar to Java – 41 of the same 43 operators, 38 of the 50 keywords (46 if you count the synonyms), and ALL the same flow of controls statements.  C# is also less verbose than the other .NET languages, and memory access is less "dangerous" since memory locations are normally accessed by reference rather than with pointers.  C# has a growing community in the VFP world, and about 25% of the C# developers are former VB developers.

VB.NET, on the other hand, is focused on RAD (think "builders").  VB.NET has more of a "pretty facade" which hides the way .NET works.  It’s more like VFP in that it is a higher-level declarative language.  VB.NET is also non-case sensitive, and has a "background compilation" scheme that catches errors earlier (which is great for small projects, but slows larger projects down considerably).  It’s best for shops with some current VB familiarity.

All the classes (also known as "types") in the .NET framework inherit from the Object class (known as "the mother of all classes").  Since two developers could easily name a class identically, "namespaces" give you a way to provide a "whole name" to your classes and allow you to categorize those classes.  For instance, the "System" namespace (provided by MS) contains the fundamental classes and base classes that define commonly used value and reference data types, events and event handlers, interfaces, and so forth.  By contrast, the "System.Data.OleDb" namespace encapsulates the OLE DB .NET data provider (which still inherits, ultimately, from the Object class mentioned above).

Because of .NET’s strong variable typing (variable types must be declared when the variable is created), and because *everything* in .NET comes from a class (and is, therefore, an object), creating a variable in .NET provides complete IntelliSense capability in the Visual Studio editor.  Entering

string test = "Hello .NET World"

and then entering

test.

provides a complete list of not only the properties of a string variable, but also the methods/functions available to that string variable.

less than 80 total lines of code, was constructed in less than 45 minutes to the delight and approval of the approximately 80 attendees.

This evening has nothing scheduled, other than the music jam session in the bar.  I think I’ll just look out over these beautiful grounds for awhile before the music starts.

Also, since .NET is strongly typed, compiling your code will produce an error if, for example, you assign a string value to an integer variable or pass an integer value to a method expecting a string (mistakes which no VFP developer has EVER made before –bg-).  This will catch a considerable number of "bugs" before the application ever runs.

.NET allows what are called "overloaded methods", or multiple methods with the same name.  A good example is the MessageBox class of .NET.  The Show() method of the class has twelve different "overloads", or ways to pass the necessary values (think of a CASE statement that accepts whatever parameters the user might pass and issues the correct call regardless).

Source code in .NET is compiled *twice* -- first to a pseudo-code level (called MSIL for Microsoft Intermediate Language) and then to machine code at run-time by the CLR.  This is different than VFP, which interprets the code at runtime.  This is important because the .NET "just in time" runtime compiler can then determine the specific CPU on which the code is running and take advantage of that processor’s special features.

Code that runs under .NET is known as "managed" code.  C++ can also create "unmanaged" code, which runs outside of .NET (VFP code would also be considered unmanaged).  "Unsafe" code is managed code which directly accesses memory using pointers and stack-based arrays.

Kevin’s presentation, which lasted almost three and a half hours with a break in the middle, was concise and communicated a large quantity of valuable information for those wishing to learn more about how .NET and VFP can coexist in the same development environment.  As always, Kevin showed a strong command of his subject matter and an easygoing, conversational style.

After the session, I met up with our other reporter, Chris Bohling, and another speaker, Ted Roche.  Most of you know Ted as the co-author of the excellent Hacker’s Guide series of books, which no VFP developer should be without.

Jim Duffy's Advisor JumpStart: SQL Server for Visual FoxPro Developers

by Evan R. Pauley

1:00 PM

On to the SQL Server for VFP Developers session and the always entertaining Jim Duffy from TakeNote Technologies in Raleigh, NC.  Jim’s sessions are always some of the most popular and best-attended at any conference, and his irrepressible personality and stage presence make his sessions a "must attend".

In a file-server environment such as VFP, large amounts of data are transmitted between the server machine and the client, and all the processing and selection of the data is performed on that client.  In a client-server environment, the only thing that is transmitted between the server and client is the request and the data fulfilling that request -- all the processing and selection of the data is performed on the server machine.

Jim advocates that ALL applications should be developed with "real" databases, such as SQL Server, Oracle, DB2 and Informix.  These databases should have integrated security, integrated scalability, integrated corruption recovery and other features missing from file-server database products such as VFP, Access, and FileMaker.

Several members of the VFP community have criticized Jim for attacking VFP as a product.  Jim addressed this directly with the attendees; he stated that he writes VFP applications every day, just without using VFP databases or tables.

Jim defined a "client-server" application as an application where the data not only resides on a single (server) machine, but is also processed on that same machine when other machines make requests for the data on the server.

Server applications are fully scalable, easier to maintain in large enterprises, allow for scheduling tasks at non-critical times, and reduce network traffic – regardless of whether the application is used by a single workstation in a single location or by thousands of simultaneous users worldwide.  Server applications also have a large selection of development tools, such as VFP, VB, Delphi, .NET, and so on.  Server applications often show increased performance, reduce network traffic, and allow for smoother data replication.

Client-server applications do have some disadvantages.  Server software is more costly; application design needs to be rethought (removing record-by-record navigation, revising forms, revising reports, etc.); and basic server administration techniques and database-specific querying dialects must be learned.  Most of these are standardized and well documented.

Jim’s presentation continued through defining various client-server terminology, such as connections, queries, result sets, stored procedures, and triggers.  He then proceeded to describe and demonstrate techniques, including advantages and disadvantages, for connecting to server data through remote views (not recommended unless data must be joined from several different data sources to an existing user interface), SQL pass-through (recommended for all queries which return data), and ADO command objects (recommended for all operations which insert, modify, or delete data).

The final hour and a half revolved around an overview of SQL Server 2000 and its various tools, followed by the explanation and construction of a basic "data object" which, when instantiated by a client, encapsulates all the necessary functionality for a single result set, including inserts and updates.  This generic data object, encompassing less than 80 total lines of code, was constructed in less than 45 minutes to the delight and approval of the approximately 80 attendees.

This evening has nothing scheduled, other than the music jam session in the bar.  I think I’ll just look out over these beautiful grounds for awhile before the music starts.

Evan Pauley, Positronic Technology Systems Llc   Evan Pauley is Director of R&D for Positronic Technology Systems LLC in Knoxville, Tennessee. Since beginning his development career in 1978, he has worked with xBase products since 1982, Fox products since 1988, and VFP since its inception. He now uses VFP and SQL Server to design and develop vertical market applications.

Yag was assigned the task of reviewing the current state of the .NET technology and community. He started his presentation with a humorous video about Microsoft public relations personnel using a focus group to attempt to find a catchy yet understandable description of .NET. The ending is too special to give away. In real life, Microsoft adopted this catch phrase about .NET: "Software for connecting information, people, systems, and devices."

Yag zipped through his material as well, which could be overwhelming to .NET newbies like me. He summarized the features of Visual Studio.NET version 2002, along with the .NET Framework version 1.0, and the additions to VS.NET 2003 and Framework 1.1.

He emphasized that the Visual Studio versions could run on the same computer together.

Ken then launched into a demo of passing data to VFP from a .NET application and passing VFP data to a .NET application. He used a Windows form and a Web form to accomplish both tasks. He also demonstrated running .NET applications in Mobile PC and Mobile phone emulators on his laptop.

Finally came the big announcement that the bonus keynote in the evening would feature previews of Europa, Whidbey, and VS tools for MS Office. To learn more about that session, read Evan Pauley's article below.

Tamar Granor's Advanced Office Automation

by Christopher Bohling

Tamor Granor, co-author of Microsoft Office Automation with VFP, used this session to discuss some of the more difficult issues facing VFP developers engaged in Office automation. She began by detailing some differences between Office servers, such as:

• whether or not more than one instance can be open at one time.
• the fact that Excel stays in memory after being "closed."
• Powerpoint's need to be visible in order to expose its full functionality.
• how the programs treat templates.

• If the VFP application will be running, create a set of methods that can be bound with the EventHandler() function.
• If VFP will not be running, build an Office add-in with VBA code that can use ADO or a COM object to access VFP data.

Andrew MacNeill's Building Better User Interfaces for Windows and the Web

by Christopher Bohling

Andrew MacNeill considers the (Microsoft-inspired) "ever-changing interface" to be a continuing attempt to make it easier to use software products. The components of the current Graphical User Interface model are Windows, Icons, Menus/Mouse, and Pop-ups. In other words, this is the WIMP interface.

But, developers might hold some misconceptions about GUIs. They are not universally deployed, they are not necessarily easier to use than text-based interfaces, and mouse-dependent input is not necessarily better than the use of the keyboard. Adding hand writing and voice recognition to GUI interfaces might help improve ease of use.

Bad Windows interfaces tend to have too many tabs, too many grids, controls that misbehave, and tool tips on everything.

Andrew offered two guidelines for building a good interface:

• Keep it clean. Do not add items just because you can.
• Make it obvious. Interpret error messages for the users and use interface elements that make sense.

For Andrew, the ideal interface is intuitive and inductive. It is task oriented. Icons are identified with assistive text. In VFP, Andrew suggested using a browser interface with hyperlinks that point to regular components.

Keep in mind that there are key requirements that have to be met for an application to qualify for Microsoft logo certification.

Finally, Andrew had to turn his attention to testing interfaces. His first recommendation was to use children, who seem to have a deeper understanding of computing than do adults. On a more serious note, he suggested building a large laboratory facility with one-way mirrors, sophisticated video systems, and research subjects who know nothing about the system. In a pinch, a simple video camera system would work. If that is too resource-intensive, just watching new users would work. If these options do not work out, the application could just be shipped to its intended users for testing.

Toni Feltman's Using Visual FoxPro to Provide and Consume XML

by Christopher Bohling

Toni Feltman focused on four mechanisms of providing and consuming XML in VFP:

• Text Merge/Text Manipulation
• CursorToXML()/XMLToCursor()
• The XMLAdaptor
• The MSXML DOM (Document Object Model)

CursorToXML() and XMLToCursor(), on the other hand, are very easy to use and not very flexible. The commands operate on a single table at a time.

The new XMLAdapter can perform multiple table conversions and hierarchical data conversions. It uses simple class-based nodes of table and field objects. It is also very flexible.

The XMLAdapter can be used in two modes: manual and automatic. The AddTableToSchema() method will automatically add tables and fields to the schema, and the XMLAdapter will instantiate the VFP base table and field classes. Table and field classes can also be built manually, by instantiating them and populating their properties. Using the manual process, specialized table and field subclasses can be substituted for the base classes.

The MSXML DOM is not VFP specific, but instead is the same XML manipulation model shared by other applications. Developers who use it will have to learn a new set of PEMs.

Among the reasons that Toni gave for using XML were to communicate with Web Services, provide more Web integration (as with hand held devices), and to manage configuration settings (instead of using the registry or .ini files).

Chris Bohling, Myers and Stauffer LC   My experience with database and application development stretches back into the 1980s, when dBase II was on the bleeding edge. In addition to Visual FoxPro®, my current set of development tools includes Visual Basic® .NET, C#, Microsoft® SQL Server™, Windows Installer, and several other applications and utilities. I am a Microsoft Certified Professional in Visual FoxPro® and Visual Basic® .NET. My experience includes full lifecycle development and maintenance work, as a team member and individually, on projects for companies in the insurance, manufacturing, construction, research, non-profit, and cleaning service industries. I spend a lot of my free time reading about software development, project management, and design patterns. I live in Shawnee, Kansas with my wife Claire and my daughter Melanie.

Keynote Presentation, Report 2 of 2

by Evan R. Pauley

8:00 am

There’s a crowd of about four hundred or so in the hallway waiting for the keynote to start. Most are reviewing their conference materials or reading the newspaper. The conference also has a wireless high-speed network available (thankfully). While I don’t know the actual attendance yet, this conference seems even smaller than I had expected. Normally, by now, I’ve run into at least half a dozen former co-workers (or employers). I’ve only seen one so far.

John Hawkins, the CEO of Advisor Publications, greeted the attendees. A series of video outtakes from the VFP team’s work location preceded the arrival of Ken Levy, VFP Product Manager, and Alan Griver, Visual Studio Data Group Manager, to begin the keynote address.

Ken began by highlighting the productivity enhancements in VFP 8, including the Task Pane, the Toolbox, the Empty class, TRY/CATCH/FINALLY structured error handling, event binding, the enhanced View Designer, and others. Ken spoke more at length about the new XMLAdapter class and its capabilities for updating data over HTTP, the new CursorAdapter class, the new data features (subclassable DataEnvironments, the BindControls() form property, etc.), and the increased performance of VFP 8 regarding object creation and release (VFP 8 is about 50 times faster in this area than VFP 7).

Next, Alan discussed the increased interoperability between VFP 8 and Visual Studio .NET. The .NET design initiative is to produce software for connecting information, people, systems, and devices. Visual Studio .NET 2002 was the first version of the .NET framework, including the new C# language. The new 1.1 version of the .NET framework is now included with Windows Server 2003, and includes side-by-side execution with the first framework version, code access security and mobile controls for ASP.NET, and native Oracle support. The upgrade to VS.NET 2003 only updates the project file; no existing source files are modified. There are also a wealth of productivity enhancements and language enhancements to all of the .NET languages and related tools, far too extensive to mention here. There are also two new certifications: MCAD (MS Certified Application Developer) and an MCSD track for the .NET framework.

Another .NET session – this one about VFP and .NET working together.  Cathi Gero from Prenia Software and Consulting in Redmond, WA begins her session by warning that Kevin McNeish might be heckling from his session next door (which drew immediate chuckles).

The advantages of VFP 8 when working with .NET include greatly enhanced XML support with the new XMLAdapter class, which allows multiple tables with relationships to be output into a single XML stream or document, the ability to work with XML DiffGrams (which work with only the modifications to the data rather than the entire table.  Additionally, the VFP OLE DB provider has been enhanced for ASP.NET Web forms and Web services, along with .NET Windows forms.

When using VFP 9 with ASP.NET, remote access to VFP information through HTTP is available.  Since ASP.NET scales well across Web farms and is platform-independent, your VFP applications can now support non-Windows users.  In addition, since ASP.NET auto-generates HTML based on the client type, using ASP.NET not only handles transparently different browsers and browser versions, but also opens your applications to mobile device clients such as Pocket PC and Web-enabled mobile phones.

Cathy stated that ASP.NET utilizing XML Web Services is the best solution for IIS web configuration, scales better across Web farms and multiple servers, and has a smoother interface than VFP for IIS/HTTP interfaces.

Cathy then proceeded to demonstrate the design of an N-tier medical application, using an XMLAdapter class in the VFP-written business (middle layer) object.  This was the same application which Ken Levy demonstrated in Monday morning’s keynote address, only more in depth.

Pushing the VFP 8 Report Writer to the Limit

by Evan R. Pauley

3:45 pm

On now to a somewhat tender subject with most VFP developers: the Report Writer.  Ever since VFP 6 came out, most have been begging for some improvements in VFP’s report handling capability.  Cathy Pountney from Optimal Solutions in Grandville, MI is the foremost expert on this subject, and this intensive session was chock-full of tidbits, tips and tricks which had everyone in the room reaching for note pads and pens.

Cathy first showed some of the design-time improvements, including the new Printer Environment check box which (thankfully) removes the need to manually clear the hard-wired printer information that is stored about the default printer on the developer’s captions* (where before, you were required to add a label control), and the new default values on the Reports tab in the Tools/Options dialog for saving the printer environment, using DBC field captions, and the default report font.

Cathy then moved on to the actual task of executing a report.  There are two ways to auto-maximize the Preview window; one, stuffing the keyboard with Ctrl-F10, works the first time – but, since that keystroke is a toggle, and is stored in the FOXUSER resource file, the next execution of the report will un-maximize the window.  Cathy’s smoother solution: place a ZOOM WINDOW “Report Designer” MAX statement in the Init() method of the DataEnvironment (no tables are required in the DE to do this).

You can suppress the “Printing …” dialog with the NODIALOG clause of the REPORT FORM command – but this should NOT be used in a COM object.  If you are using this clause with either the PROMPT or PREVIEW clauses, the NODIALOG must be after the PROMPT clause and before the PREVIEW clause to correctly operate.

You can determine whether the user is previewing or printing the report by checking the SYS(2040) function.  This function returns a *character value* of “0” if no report is being executed, “1” if the user is previewing, and “2” if the user is printing.

You can “chain” reports by using the NOPAGEEJECT clause (to keep the print job open) and the NORESET clause (to keep page numbers from resetting after a report).  If you are chaining reports in a SCAN loop, you must manually close the print job – to accomplish this, execute a dummy report with no output and neither of these clauses.

You can use the new _PAGETOTAL system variable to get the total number of pages for a report, which allows you to print “Page X of Y”.  This forces a “double pass” through the FRX.  The first pass is only to set the system variable; if UDF’s are being called, the developer needs to be certain that these only fire on the second pass (to accomplish this, check for _PAGETOTAL > 0 before executing the UDF).

When combining fields in a single control (ie, Address1 + Address2 + City + State), it is not necessary to check each field for emptiness or ALLTRIM() each field.  A semicolon between two fields says “add a CR if one of the fields isn’t blank”; a comma between two fields trims the fields and adds a space if one of the fields isn’t blank.

If your labels don’t stay even with your “floating” fields, add a line control with a white color between the controls you wish to keep “level” with each other.  This will force the labels to be maintained at the top of the floating field to which they reference.

Evan Pauley, Positronic Technology Systems Llc   Evan Pauley is Director of R&D for Positronic Technology Systems LLC in Knoxville, Tennessee. Since beginning his development career in 1978, he has worked with xBase products since 1982, Fox products since 1988, and VFP since its inception. He now uses VFP and SQL Server to design and develop vertical market applications.

<mobile:Form runat="server">
  <mobile:Label runat=“server">
    Hello, Mobile World
  </mobile:Label>
</mobile:Form> 

Also, Cathi presented two examples of ASP.NET output, the first for a WAP phone and the second for a Pockect PC.

<?xml version='1.0'?>
<!DOCTYPE wml PUBLIC '-//WAPFORUM//DTD WML 1.1//EN' 
'http://www.wapforum.org/DTD/wml_1.1.xml'> 
  <wml> 
    <card> 
      <p>Hello World</p> 
    </card>
  </wml> 

<html> 
  <body>
    <form id="ctrl1" name="ctrl1" method="post“ 
             action="example.aspx"> 
      <div>Hello World</div> 
    </form>
  </body> 
</html>

Cathi's slides listed the mobile controls and discussed their major features. The controls fall into the categories of containers, text display, list and selection, control transfer, command, image display, calendar, and validation.

Control transfer is using a control as a hyperlink to another form on the device.

A command control, the phone call control, generates hypertext to make a call. A phone emulator gives different output than a browser. This is due to a predefined alternative in the AlternateFormat property.

Cathi demonstrated that ASP.NET would automatically remove a column from an object list because the screen on the phone device was not wide enough to show it. On other hand, a Pocket PC could show it, so ASP.NET included the column in the output.

Image controls display image files and can have associated URLs. Some devices can not support these.

According to Cathi, the Calendar Control is very rich, but can be cumbersome. It renders differently on different devices.

There are six validator controls. These are the same as in Web page development.

The DeviceSpecific Control uses DeviceFilters to determine which output to send based on the device. For instance, one device might support color and another not. Filters are interpreted as sets of choices (IFs) in ASP.NET code.

The StyleSheet control allows you to set styles for different types of text. Styles are assigned with the StylePreference property.

Cathi stepped through a mobile application that she developed. The application selected a series of Datasets over the Internet as the user navigated a series of data forms that are in one ASPX page. For each form, a Dataset is created and the controls are bound to the data. The user starts by selecting the country and clicking on a command button. The command button click sends the country ID to the server, which queries cities by country. The Dataset is returned, bound to a list, and the city form is made active.

Selecting cities and clicking on the Customers button results in a similar process for selecting and showing customers. For each customer, a Dataset of orders can be retrieved.

Cathi concluded by pointing out the number of resources available to assist developers doing mobile development.

The Closing Session

by Christopher Bohling

The closing session was arranged in a question and answer format with a panel of remaining speakers providing the answers. The one major rule was No Marketing Questions. This made it easy for moderator Andrew MacNeill to toss a few questions immediately into the trash, like "When will Europa be released?"

An interesting early topic that was raised but not answered was why the VFP DevCon focused so much on .NET. Couldn't there be a "pure" VFP conference?

The first couple of serious technical queries, however, were hard for the panel to answer and so were also labeled "marketing questions."

Whether it was a marketing question or not, the audience persisted in wanting to know when and where the next Advisor DevCon would be held. Andrew tried to reassure everyone that there would be a 2004 DevCon, as one of the prizes being distributed at the session was a certificate for free regristration.

The paucity of questions from the audience kind of left the speakers a little bit dumbfounded. Tamar Granor asked, "Does this lack of questions mkean that during this conference you learned everything you need to know?" The audience responded with enthusiastic applause.

The other major activity of the session was giving away prizes to people who had done good things, like filling out evaluations and the scavenger hunt form. Prizes included items such as autographed copies of What's New in Visual FoxPro 8, The Hacker's Guide to Visual FoxPro 7, a 24-port switch (!), and free admission to the next DevCon.

The recipient of the certificate for free admission was chosen by a game where audience members had to put their hands either on their head or their "tail," and then a coin was tossed by an Advisor representative. If your hand location matched the coin result, heads or tails, you were still in the game. Otherwise, you werer out. In no time, the number of remaining players was down to about six, and the next toss determined the winner.

As that basically wrapped things up, the Advisor representative thanked everone for attending and said goodbye. This was followed by an immediate chorus of questions about the next DevCon. The representative answered that there would be a next DevCon, but the where and when were undetermined at this time.

Chris Bohling, Myers and Stauffer LC   My experience with database and application development stretches back into the 1980s, when dBase II was on the bleeding edge. In addition to Visual FoxPro®, my current set of development tools includes Visual Basic® .NET, C#, Microsoft® SQL Server™, Windows Installer, and several other applications and utilities. I am a Microsoft Certified Professional in Visual FoxPro® and Visual Basic® .NET. My experience includes full lifecycle development and maintenance work, as a team member and individually, on projects for companies in the insurance, manufacturing, construction, research, non-profit, and cleaning service industries. I spend a lot of my free time reading about software development, project management, and design patterns. I live in Shawnee, Kansas with my wife Claire and my daughter Melanie.

Using Event Handling in VFP 8

by Evan R. Pauley

8:00 am

Markus Egger from EPS Software in Houston, TX presented the first session of the day on the new event handling features of VFP 8.  Marcus, among many other things, is well known as a several-time Microsoft MVP in VFP and is also the architect of the Voodoo Web Controls.

In an object-oriented methodology, an event is some occurrence that asynchronously “happens”.  The event itself is referred to as a “delegate” (think “pointer to another piece of code”).  Events can have “signatures”, or various parameters which are passed to that piece of code.  An “event handler” is, then, simply a method that reacts to an event.

All VFP controls raise events, and have their own event handler methods.  However, event handler methods are NOT the same as the events, even though they may have the same name (for example, the Click() method of a command button is not the same as the Click event; the method is the event handler).

In VFP 7 and before, you could not alter which piece of code the event used as its event handler.  VFP 8 can now attach *any* piece of code to any event with the BINDEVENT() function.  The piece of code will fire *in addition* to the previously bound event handler, and the developer, using properties of the function, has a certain amount of control as to the order in which these pieces of code fire.  The UNBINDEVENTS() function reverses the process and detaches all event binding added by the developer (the native VFP event handler is left intact).

To determine what is firing when, the AEVENTS() function returns an array information about the last event that fired.  The RAISEEVENT() method fires all the attached event handlers in the specified order.

by Evan R. Pauley

9:45 am

We’ve been learning about how to write apps; now we get to learn how to install them.  Andrew MacNeill of AKSEL Solutions in Canada has the next session, Deploying VFP 8 Applications with InstallShield Express (interestingly enough, he has subtitled his session “I already paid for one tool – I don’t want to pay for an installer too”).

If you never need to deploy an application, you don’t need to learn about an installer (smile).  But, since most of us must deploy our work to users occasionally, and since XCOPY just doesn’t seem to do the job in the Windows world anymore, the Windows Installer was born about halfway through the development process for VFP 6 (six).  Windows Installer makes use of “merge modules” which tell the installer about all the necessary files to include in the installation, and tracks the files being used to reduce the chance of deleting a shared file.  Unfortunately, the Installer interface for creating a merge module was overly complicated to use and maintain, and used the Setup Wizard (which most developers hated).

Starting with VFP 7, InstallShield Express 3.0 (ISE) replaced the Setup Wizard.   ISE 3 was a “customized for VFP” (read: ”limited”) version of the actual ISE 3 product, which was a limited version of the professional version – basically, a wizard of a wizard.  This was considered “two steps forward and one step back” by most VFP developers, especially when they discovered the limitation of not being able to run any specialized code after the setup had been completed!  Additionally, since ISE uses a scripting language (which can be somewhat arcane), using the tool required the developer to learn yet another syntax.

VFP 8 includes version 3.5 of ISE, which is a considerable improvement over the previous incarnation.  ISE’s interface allows the developer to control MOST (but not all) of the properties of the Windows Installer merge module that ISE builds.  Andrew proceeded to describe the organization of ISE, how to add features and install COM objects along with your application, how to specify which operating systems on which your application will allow itself to be installed and in what locations, what additional software shortcuts are desired, and how the target system should be configured.

by Evan R. Pauley

2:00 pm

The final “content” session of the day concerned VFP 8’s performance with large databases, presented by Mac Rubel of EPS Software in Houston, TX.  Mac has a long history and excellent reputation in the VFP world performing these type of benchmark tests with VFP and its data performance.

Mac’s test machine was a 2.4 GHz processor with one 40GB and one 80GB hard drive and a 100 Base-T network card.  Mac’s benchmarking methodology attempts to minimize as much as possible the Heisenberg principle (which states that the act of observing changes the conditions of the test, and therefore alters the results).  Before each test, Mac wipes the 80GB drive and restores from another drive the exact image in the exact order.

The SYS( 3050, n ) function (everybody knows this one off the top of their head, right?)(mmm-hmmm, that’s what I thought) returns various “amount of memory available” values.  VFP slows down precipitously when the operating system “tricks” VFP into thinking that it is working with real memory, when in fact the OS has allocated “virtual memory” (read: disk space).  This doesn’t happen often, since VFP is reasonably smart about these things, and usually only occurs when several applications are running simultaneously or several large data sets are being handled at the same time.

Mac’s databases sizes for testing bump up against the 2GB file size limit imposed by VFP.  Mac demonstrated that as table size increases (and therefore the use of memory increases), VFP has enough intelligence to maintain a consistent, flat curve in its speed of indexing the table.  Surrogate keys are ALWAYS better than meaningful keys for business purposes, and integer keys will ALWAYS perform about 7% faster than BINTOC() keys, about 22% faster than character keys, and about 25% faster than numeric keys regardless of the table size.

Mac also showed that increasing CPU speed does not necessarily show a corresponding increase in execution speed.  In fact, increasing processor speed only provides a small percentage increase (usually 5 to 15 percent); increasing disk size, speed and/or throughput is better, but only slightly.  When comparing local access vs. network access to a LAN server, SQL SELECT statements are faster on the server because of the more efficient caching on the server, regardless of the speed of the network.  Indexing, however, varies based on the speed and the topology of the network (switches are faster than hubs, and so forth).  Both LAN scenarios vary widely depending upon what other network usage tasks are being performed.

Memory size causes the most variance in performance.  When indexing 1 million records, there is a large drop in speed when available memory is increased from 128MB to 256MB, but the curve is almost perfectly flat with greater memory values.  Above 512MB of memory, few if any performance benefits are achieved.

Evan Pauley, Positronic Technology Systems Llc   Evan Pauley is Director of R&D for Positronic Technology Systems LLC in Knoxville, Tennessee. Since beginning his development career in 1978, he has worked with xBase products since 1982, Fox products since 1988, and VFP since its inception. He now uses VFP and SQL Server to design and develop vertical market applications.