Sessions by Track

Presenter: Kevin J Cully
Level: Beginner, Intermediate

You will learn:

• The fundamental concepts of neural networks compared to expert systems and the benefits to each
• How the lines between Neural Networks and Expert Systems can be blurred with the advance of Deterministically structured databases
• How AI adds knowledge and reasoning to existing applications. to make them friendlier, smarter, more sensitive to user behavior and more adaptive to changes in the business environment
• How the rise of the Internet can be leveraged as a database to build knowledge easily

Prerequisites: A general knowledge of Visual FoxPro programming and database concepts.

Presenter: Tamar E Granor
Level: Beginner, Intermediate

In this session, we'll cover the basics of using collections, the reasons why they're better than arrays, and show how they improve object models. We'll also consider the weaknesses of collections in VFP and talk about workarounds.

You will learn:

• What collections are and how to work with them
• Why they're easier to use than arrays in VFP
• How they fit naturally into object hierarchies
• How to debug collections

Prerequisites: Some familiarity with OOP

Presenter: Steve Ellenoff
Level: Intermediate, Advanced

If you've ever worked with more than one SQL back-end, you'll appreciate the complexity and difficulty that comes in wanting to support more than one, especially with the same set of code for your VFP applications. At first blush you might think that Remote Views or the Cursor Adaptor can handle this without any additional steps, but as this session will demonstrate, this is not the case.

In this session we will examine a strategy for creating database abstraction classes which hide all the complexities of working with various different SQL back-ends, including FoxPro local data. By using this approach your applications become decoupled from the back-end and can switch easily without recoding, even on the fly. The session will also cover the advantages and disadvantages of this approach, under what circumstances you may wish to use this technique, and how you can easily extend the classes to handle SQL back-ends that do not even exist yet.

You will learn:

• Why it can be difficult to support multiple SQL back-ends
• Why Remote Views and the Cursor Adaptor are not the solution
• How to create a Database Abstraction Class (DAC) to enable supporting and switching between multiple back-ends easily
• The advantages and disadvantages of using a DAC for your VFP projects
• How to extend the DAC classes to support future SQL database back-ends

Prerequisites: Some familiarity with Business Objects, SQL Pass-Through, and at least one of the following back ends: Microsoft SQL Server, MySQL, PostgreSQL

Presenter: Rick Borup
Level: Intermediate, Advanced

You will learn:

• What design patterns are
• How patterns help solve common object-oriented design problems
• How to recognize opportunities to apply design patterns in your own work
• How common design patterns can be implemented in Visual FoxPro

Prerequisites: Experience developing object-oriented applications in Visual FoxPro

Presenter: Cathy Pountney
Level: Intermediate, Advanced

You will learn:

• About the fxReports project on VFPX (CodePlex)
• How to implement custom report features created by other developers
• How to develop your own custom report features
• How to share your custom report features with other developers

Prerequisites: Familiar with VFP Reports

Presenter: Cathy Pountney
Level: All levels

In this session I'll start by showing you the basics of installing, using, and customizing the PEM Editor. Then we'll get into the cool stuff like copying properties and methods (including code) from one class into another. We'll look at a bunch of cool IDE tools such as Enhanced Beautify, MRUs, and Go To Definition. We'll also explore one of my favorite features; the new design-time event handlers and builders. With this feature you can put code in your classes and the PEM Editor can automatically fire that code at various times. For example, resize a container at design-time and objects inside the container can automatically resize too! Think of the possibilities! Drop a container on a form, resize it, and everything inside resizes without any additional design work!

Come see why I'm so passionate about this development tool. And knowing how many new features Jim keeps adding, I'm sure they'll be even more new features added between now and the start of Southwest Fox. Don't miss this session. Come see what all the buzz is about!

You will learn:

• How to install and customize the PEM Editor to your preferences
• How to use the basic features of the PEM Editor
• How to use the bells and whistles in the PEM Editor
• How to use the PEM Editor to implement design-time features in your classes

Prerequisites: None

Presenter: Christof Wollenhaupt
Level: Intermediate

In this pre-conference session we will extend a real-world application with some new features. "Real world" here means a typical, really messy, historically grown application; not a demo application carefully crafted for a session.

During the course we will start by using test-driven development which mainly means unit testing code. However, test-driven development is more than just writing some tests. By strictly limiting additions to whatever is needed to make the test pass, we avoid writing overly complex code.

As we move along with testing we will automatically discover the need for other object oriented design principles and apply them in the VFP world, including:

• Single-Responsibility Principle
• Open Closed Principle
• Liskov-Substitution Principle
• Inversion of Control
• Don't Repeat Yourself

These principles are one possible way to achieve a solid design and implementation.

There's always more than one way to skin a cat, though. Sometimes you have to violate the principles above on purpose. We will cover situations where either the technology (that is, VFP) doesn't support them, or other limiting factors in the real world prevent us from doing so.

At the end we will apply these principles to some well-established techniques in the VFP community such as the global application object, meta-data driven applications, and other VFP specific solutions. 15 years after their introduction some of them might better be replaced by more current approaches.

You will learn:

• How to use "clean code development" practices
• How to recognize good and bad design
• The concepts and reasons behind the principles

Prerequisites: Fundamental OOP and VFP knowledge