My last day started with Christof Wollenhaupt's "Optimizing and Debugging" session. In this presentation Christof demonstrated many good debugging and optimizing tips. Some of my favorites are:

• When building a new application, work on the data migration before the forms and reports. This way you will have good sample data to test the forms and reports with.
• Design to match complexity. For example, N-Tier is a good idea for enterprise systems, but probably overkill for a hobby application.
• Avoid defensive programming such as parameter checking. It can promote bad coding practices.
• Forms make horrible progress bars because they change focus (Activate and Deactivate events), which can interfere with debugging. Use a toolbar instead. This also has the benefit of always being on top.
• Use a hotkey to turn the Coverage Profiler on and off.
• When using Coverage Profiler, keep in mind that the time it takes to log an event can make a line of code that normally executes quickly appear much slower due to the overhead.
• Use SCAN FOR instead of REPLACE FOR whenever possible because the REPLACE FOR command has to do a table lock, versus a record lock.

My last session of the conference was Craig Boyd's "VFP Fundamentals: Creating a Professional VFP Application from Start to Finish". Craig began with how he likes to setup his project folders, how he uses Subversion for version control, and sub-classing the base classes. He also discussed user interface best practices, such as using one font, using colors sparingly, avoid creating a battleship (black, white, and gray only), and being consistent in how you layout and size things.

My favorite part of his demonstration was an awesome grid that he created. It had really cool features such as column sorting, incremental search and filtering (very similar to Microsoft Excel), export capabilities, and the ability to save and restore how a user customizes the grid (i.e. column re-ordering and re-sizing).

Saturday began with Doug Hennig’s “Creating Explorer Interfaces in Visual FoxPro” session. This presentation was about creating an explorer like interface similar to Windows Explorer using a TreeView control and the VFPX OutlookNavBar component.

Besides being an excellent speaker, Doug’s sample code and white papers are alone worth the price of admission. For example, Doug does not just use the standard TreeView control. He extends it by automatically linking an ImageList control, proving node load control, adding double click and right click functionality, adding “go back” support, adding support for saving and restoring the state on close/open, and more. Did I mention that it is also data-driven? That’s just awesome.

The second session of the day was Andrew MacNeill’s “Working with CodePlex and VFPX”. In this presentation Andrew discussed the basics of VFPX, how to use the CodePlex site, and how to access the source code. I’ve always felt like the VFPX site was a little confusing to navigate so it was nice to get a demonstration.

The third session was Alan Stevens’ “Manage Complexity with Agility”. This was my first time hearing Alan speak. I had heard good things about his presentation last year, so I was eager to experience one this time. I have to say, Alan exceeded my expectations. His presentation contained a lot of good ideas about the software development. For example, on the topic of software schedules, Alan suggests delivering something every 1 to 2 weeks. It is better to find out what you’ve done is not what the customer wanted, even though it may be what they asked for, sooner than later. He discussed that most customers are not technical and therefore cannot provide formal requirements. What you can do is get the user to explain what they need in short descriptions, a.k.a. user stories. A user story consists of a role, a need, and a reason.

Alan also demonstrated unit testing with FoxUnit, and automating builds using VFP MSBuild Target. FoxUnit is an open source unit testing framework from VisionPace. VFP MSBuild Target is a VFPX project for performing Visual FoxPro builds.

After lunch I attended Doug Hennig’s “Advantage Database Server for Visual FoxPro Developers” session. I was really interested in attending this session so that I could get some first-hand knowledge about this product from a trusted Visual FoxPro developer.

Doug did a really thorough job of explaining what Advantage Database Server (ADS) is, how to install it, and how to use it with Visual FoxPro. This session covered a lot of material, so I’m going to limit my comments to my favorite three things.

Second, ADS supports accessing Visual FoxPro data both as native tables and through ADS. This means that you can slowly convert an existing system to a client server model one module at a time. For example, you could change one form to access the data using ADS, while the rest of the system continued to access the tables directly. The end goal would be to change all the forms to use ADS, but this one module at a time approach allows you to first concentrate on the portions of the system that need the conversion to client server the most. How cool is that?

And finally, the ADS full text search capability. This feature alone could be enough reason to use this product. Doug started by creating a table with 80,000+ records (60MB DBF) that had a 500MB FPT file. He then performed a search with both Visual FoxPro and ADS. The results speak for themselves.

• Visual FoxPro Case Insensitive: 305 seconds
• Visual FoxPro Case Sensitive: 60 seconds
• ADS: 0.07 seconds

My last session of the day was Alan Stevens’ “Ignorance is Bliss: Why You Don't Need to Know Where or How Your Data is Stored?”. Alan discussed the idea that an application should not tightly coupled to the data. This makes it possible to have a more flexible system that can support different data sources.

Unlike his other session, Alan walked through quite a bit of sample code in this session to show this could be implemented using XML to transport the data. Alan warned that the Visual FoxPro XMLTOCURSOR() function tends to hang when the size of XML reaches about 11MB. His solution, was to use the XML DOM object in a loop to process the XML in batches of 500. I’ll have to keep that in mind if I ever run into that problem in the future.

Day 2 started with Andrew MacNeill's “Profiling and Refactoring: How to Analyze and Clean-up Your Code” session. This was my first time seeing Andrew present, although I've been reading his blog and following his podcast The Fox Show for some time now. The two big things I got out this session were Code Analyst and Coverage Profiler tip.

Code Analyst is an open source developer tool on VFPX that is used to evaluate code against a set of user defined rules. For example, there could be a rule that PUBLIC variables are not allowed. There could also be a rule that every method/program/function must have a RETURN. Code Analyst would then scan the source code and document which rules were broken and where at in the source code. Kind of like a Code References on steroids.

A really cool feature of Code Analyst is that it supports four types of rules: method, line, object, and file. A good example of a method rule is the RETURN command. Each method must have at least one. Or only one, depending on you was raised {g}. Whereas checking for a PUBLIC variable would be something that is done for each line.

One idea I had for using Code Analyst is enforcing Software Development Standards (a.k.a. this is how we do it here). For example, I could have a function for opening tables called OpenDBF(). Therefore, the USE command should only exist in this function. I could create Code Analyst rule to check for the USE command.

As for the Coverage Profiler tip. Anyone who has used Coverage Profiler knows that the LOG file it generates can get big real fast. Disk space is not the problem so much as getting the Visual FoxPro Coverage Profiler Analyzer tool to process a 100+ MB file. Andrew suggested importing the LOG file into a table and then deleting the entries that were not important. For example, I could delete entries based on the filename, class, or the time it took to execute. After that I’ve got something that is probably a lot easier to grok.

The second session of the day was Christof Wollenhaupt’s “Introduction to Mobile Development”. This presentation covered the basics of developing software for mobile devices. Christof discussed how to setup a virtual mobile device for testing, mobile device limitations such as screen size and API, and did a demonstration of how to use the alternative Visual FoxPro runtime Guineu for running VFP applications on a mobile device.

Next I attended Rick Strahl’s “Using Ajax and jQuery features to build Rich Web User Interfaces with Web Connection” session. Rick explained what jQuery is, why you want to use it, and demonstrated some cool examples. He stated the number one reason for using something like jQuery is the normalization across the different browsers. He also mentioned a blog post on his web site where he explains how to add jQuery IntelliSense to Visual Studio. Although it sounded like Microsoft should be adding that feature soon.

After lunch, it was time for Craig Boyd’s session “VFP Studio: Extending the Visual FoxPro IDE”. Ever since the Southwest 2007 keynote where Craig and Bo Durban first did a sneak peak of VFP Studio, I’ve been waiting to hear more about VFP Studio. Craig explained that VFP Studio is a replacement for the Visual FoxPro IDE. For example, the MODIFY COMMAND window, Class Browser, Project Manager, Form Designer, and etc. It is not a run time replacement, like Christof’s Guinea or eTechnologia's VFPCompiler for .NET projects.

Craig went on to explain that VFP Studio was created with Microsoft Visual Studio SDK. This same SDK has already been used to create IronPython and a few other IDEs. He stated the biggest problem with the SDK is that it is so huge that it can be quite overwhelming. He also mentioned that it is still evolving, so sometimes a new release will break existing code.

Craig was able to demonstrate some of what he and Bo have already completed. What I saw was very cool. I especially like code editor and form designer features.

Replacing the Visual FoxPro IDE may not sound like a cool idea if you have never worked with Visual Studio. Trust me, it is {g}.

Craig wrapped up with a call for help. He and Bo are currently looking for developers with C# and Visual FoxPro experience. They also have a need for testers. So if you are interested, please contact either of them directly via email at SweetPotatoe Software or Moxie Data.

Next I attended Christof Wollenhaupt’s “Creating Owner Drawn Controls in Visual FoxPro” session. In this presentation Christof demonstrated how to create your own controls (i.e. page frames, progress bars, and etc.) using GDI+. I would call it a basic how to guide for creating the same kind of cool things you see on VFPX like ctl32 StatusBar and FoxCharts.

One of the coolest parts of this session was an example of an Office 2007 style floating menu bar. You know the one that pops up when text is highlighted and the mouse is positioned over the text. Very cool.

I also enjoyed the way he “converted” a complete Visual FoxPro form to a .NET GUI with the click of a check box. Everything from page frames and option groups to text boxes. That was pretty slick.

The last session of the day was Rick Strahl’s “Using .NET with Visual FoxPro for Reliable Web Service Access and Hosting” session. Rick discussed the current state of Web Services and Visual FoxPro, how to use .NET via COM Interop, and the differences between ASMX and WCF.

I must admit that I have only done a few web services so far, mostly Visual FoxPro server to Visual FoxPro client. It was good to see what my options are for the future and to be able to squirrel away some sample code and notes {g}.

One of the questions I get asked most often by someone who could not attend the conference is what happened during the keynote? Traditionally the keynote is when big announcements are made and new cool stuff is publically previewed. For example, last year Craig Boyd and Bo Durban demonstrated VFP Studio.

This year the organizers of the conference did something different that I think was really cool. A live video broadcast streamed over the internet.

So, if you missed the live broadcast or just want to see it again. It is available for viewing at http://www.ustream.tv/channel/swfoxtv. Be sure to catch the "magic" of Craig Boyd and Bo Durban about 57 minutes into the video {g}.

One last thing. I want to thank Steve Bodnar of Geeks and Gurus for making this happen. He did all of the work solo. From the setup and testing, to shooting the video and handling the chat window. Way to go Steve!

Today began with Andy Kramek's pre-conference session - Introduction to Transact SQL. This session covered the basics of Microsoft SQL Server Transact SQL (T-SQL). From variables, temporary tables, and common table expressions. To functions, stored procedures, triggers, and more.

My favorite part was the explanation of how Microsoft SQL Server, and most other database management systems, process a SELECT command. Andy took us step by step how the query engine builds each of the intermediate result sets, the order everything is processed in, and how Visual FoxPro's engine works slightly different.

Knowing this helps me understand how to build better SELECT commands. It also explains why a SELECT command might not always do what I expect it to. Great information.

I started today with Doug Hennig's session Best Practices for Vertical Application Development.  Although I had attended this same session previously at the 2006 Great Lakes Great Database Workshop conference, I still managed to learn some new things.  If you missed this session I have a couple of book recommendations of my own.  Check out "Eric Sink on the Business of Software" by none other than Eric Sink.  And finally "Micro-ISV: From Vision to Reality" by Bob Walsh.

My last session was Marcia Akins QuickBooks Automation.  Marcia did an amazing job of demonstrating of how to get started with the QuickBooks COM component.  I especially liked all of the "gotcha" warnings.

In summary, I had a really good time at Southwest Fox this year.  It was good to see some old friends, make some new ones, and learn new ways to use my favorite development tool - Visual FoxPro.

My first session of the day was Christof Wollenhaupt's Using CVS and Subversion with VFP.  Since I have only used Microsoft's Visual Source Safe and Sourcegear's Fortress, I was curious as to how CVS compared.  It is definitely something I would consider using in the future.  Christof also showed a utility he wrote to convert Visual FoxPro files into XML files before checking them into Source Code Control.  The utility also has the ability to convert the XML files back to binary files - very cool!  For those who are interested, you can download the TwoFox utility from his website at http://foxpert.com.

The next session was Craig Boyd's The Power of Regular Expressions.  I must admit that I never tried Regular Expressions before because they looked so complicated.  However, after Craig's presentation I've come to realize that they really are not that bad once you know the basics.  Of course it helps that Craig did an awesome job of explaining what how to read and write regular expressions, how to use them, and provided plenty of good real world examples.

Following lunch I attended Steve Sawyer's Basic Marketing for Custom Business Software Services session.  Steve had some very interesting ideas on marketing and networking.  He also recommended another book for the reading list - Rain Making: The Professional's Guide to Attracting New Clients by Ford Harding.

After that I went to Whil Hentzen's So You've Inherited an Application. Now What?  A lot of this session was geared towards custom software development shops with some good general programming ideas mixed in.  For example, when you are working on a project - don't end your day by stopping at the end of the module/class you were working on.  Try to stop somewhere in the middle and document what you had left to do.  The next day you'll find that you are able to get into the zone much faster.

Day 2 began with Steve Sawyer presenting a session on Software Project Management.  During the past couple of years I've taken more of an interest in the business side of software development, therefore this session was something I was really looking forward to.  Steve did a good job of explaining what a project manager is, and just as important, is not.  One key point that I got from the session was that project management requires a lot of diplomacy when they take the role of a liaison between customers and technical people.  Steve also recommended a book by Thomas Friedman, "The World is Flat".  I'll have to add that to my reading list.

My next session was Michael Hogan's 254 Fields in that Table?  This presentation addressed the problem where you need to store different fields for each record in a table.  For example, an Items table contains a record for Shoes and a record for Blenders.  Each Shoe item has a Brand, Color, and Size attribute.  Whereas each Blender item has a Brand, Motor Speed, and Watts attribute.  He demonstrated several common solutions such as a single flat table, many related tables, a generic attribute table, and using embedded XML.  Michael discussed the pros and cons of each solution, with last one being the best overall solution.

My third session was Christof Wollenhaupt's Introduction to COM.  This session discussed the history COM, what makes it so cool.  He also offered an excellent rebuttal to the argument that COM is dead and went on to provide evidence to the contrary.  A real highlight of this session is a function he wrote that can be used to load DLLs without registering them first!

After lunch, I attended Whil Hentzen's session Introduction to Client-Server Using VFP and MySQL.  One of the topics he discusses is the problem of loading MySQL on a development machine.  It is easy to be misled by the performance since the data is "local".  I though about this and wondered if running MySQL in a virtual environment, such as VirtualPC or VMWare, would address that issue.  If this topic was something you missed, I would suggest checking out Whil's book "MySQL Client-Server Apps with Visual FoxPro" at Hentzenwerke.  Having read the book and attended the session, I would say that the book covers what he presented and more.

Following that I went to Christof Wollenhaupt's session On the Dark Side of FoxPro.  This session explained a lot about how Visual FoxPro works internally.  He discussed data sessions, object creation, variables, memory management, tables and indexes, Rushmore optimization, and so much more.  This is one of those times when you don't want the presentation to end because you are learning so much.

My last session of the day was Doug Hennig's Developing Visual FoxPro Applications for Windows Vista.  Doug did an excellent job of explaining what has changed in Vista, how it affects application development and deployment, and what we need to do for our applications to run on Vista.  One of Doug's comments was something to the effect that Vista is not going to go away anytime soon - so we might as well get used to it.

Day 1 began with Michael Hogan's pre-conference session No Boundaries: Visual FoxPro Web Applications.  Michael did a great job of explaining the differences between web applications and desktop applications; and the advantages/disadvantages of both.  I especially liked the way he demonstrated "statelessness" using audience participation.  In addition he showed us some of his deployed solutions and took us for a tour behind the scenes.  If you want to get started in web applications, this session was a great way to begin.

After a quick dinner break, it was time for the Keynote.  I'll skip most of the details and jump straight to the cool stuff.

First, Christof Wollenhaupt demonstrated his Guineu project.  Guineu is an alternative runtime that allows a Visual FoxPro application to run on multiple platforms (Windows, Pocket PC, and Linux) without any modifications to the code.  Guineu is currently in development, but it still looks very promising.

Next, Toni Feltman demonstrated a couple of eTechnologia's developer tools.  The first tool was .NET Extender.  It provides the ability to use any of the .NET classes (including controls) in Visual FoxPro.  The second item was VFPCompiler for .NET.  This tool compiles Visual FoxPro forms and classes (SCX, VCX, and PRG) into pure .NET IL Managed Code.  Both of these tools are currently in alpha stage.

Finally, Alan Stevens and Craig Boyd demonstrated something they called "VFP Studio 2008".  It uses something that will be new in Visual Studio called the "isolated shell".  I wish I could explain more, however due to the time constraints they were not able to provide a whole of details.  So, I'm just going to leave it at that for now.  Hopefully Craig will be able to talk more about it on his blog at Sweet Potato Software.