|
|
There are three pre-conference sessions and 27 conference sessions. Click a track's icon
to jump to the sessions for that track.
Pre-Conference Sessions
|
Presenter: Michael Hogan
Level: Intermediate
When: Thursday, October 18, 1:00 - 5:00, Fairway 3/4 |
 |
There are tens of thousands of web hosted applications run using Visual FoxPro (a recent Google search found over 850,000 web pages). We will see several live money-making web applications running in Visual FoxPro with West Wind Web Connection. This session is an overview of the capabilities and technical requirements of VFP on the Internet for both businesses and for the general public.
We will discuss, show and diagram standalone web applications, client-server arrangements, and simple and inexpensive ways to generate web content from Visual Foxpro. All it takes is learning simple HTML techniques.
In this session, you will learn:
- Generating web content for daily FTP uploads to a conventional web site
- Uploading and Downloading data between client and server
- When to use native VFP tables, and when to use SQL
- Thinking about "Stateless" application design
- What equipment is required to webify your applications
- What NOT to expect when moving an application to the web
- The philosophical differences between Desktop GUI and web GUI
|
Presenter: Andy Kramek
Level: Intermediate
When: Thursday, October 18, 8:00 - 12:00, Fairway 3/4 |
|
The first part of this session covers the basic concepts that underpin client-server development and shows how Visual FoxPro can be used in conjunction with SQL Server to create true three-tier client-server applications. This part of the session addresses the question "What is a Client Server Application" and covers:
- System Architecture
- Application Structure
- Why bother with Client-Server?
- Why use Visual FoxPro at all?
- Basic data management strategies
The second half of the session is focused on the mechanics of working with remote data and addresses the question "How do I build a Client Server Application" and covers:
- Connecting to the Database
- Retrieving and Updating Data
- Implementing Server-Side Code (Stored Procedures, Triggers and Transactions)
- Traps and pitfalls for the VFP Developer
Note: This session is not a tutorial on how to use remote views, CursorAdapters or SQL Pass Through. It does include a review all of the VFP tools and places them in context by indicating their relative strengths and weaknesses. However, the main focus is on the differences in application design and development that are required when working with a Client-Server architecture.
In this session, you will learn how to:
- Connect to the Database
- Manage Users and Basic SQL Server Security
- Recognize the differences between VFP and SQL Server Databases
- Create a Database, and all main components (Tables, Views, Indexes, Constraints, Default Values, GUIDs, Timestamps and User defined DataTypes
- Use Transact-SQL to create Triggers, Stored Procedures and Functions
- Detect and Handle Server Side and Client Side Errors
- Manage SQL Server Transactions
- Create complex T-SQL procedures to extend functionality
|
Presenter: Alan Stevens
Level: Beginner
When: Thursday, October 18, 1:00 - 5:00, Fairway 2 |
|
Test Driven Development (TDD) is the practice of writing test code before writing implementation code. While this may seem like an undue burden, it actually forces the developer to define inputs and outputs up front, enforces modularized code, and improves maintainability thereby increasing productivity over the lifetime of the application.
FoxUnit is a freely available unit testing framework for Visual Foxpro. Unit testing alone is not TDD. A TDD process implies that the test is written, run, and fails first: red. The minimum necessary implementation code is written to pass the tests: green. Only then is the code modified for clarity, elegance, robustness, etc.: refactor.
While this session will include several demos of TDD using FoxUnit, a substantial portion of our time will involve reviewing the assumptions behind the TDD approach. VFP developers are very practical, and this session is intended to provide ample evidence that TDD is a practical and productive approach to software development.
This session will teach you:
- How to approach requirements with from a TDD perspective
- How to setup and use FoxUnit to create unit tests
- The economics of "eating your spinach"
- How TDD fits with the typical VFP approach to new development
- The joys of refactoring once tests are in place
Conference Sessions
|
Presenter: Marcia Akins
Level: Intermediate
When: Friday, October 19, 4:15 - 5:30, Fairway 3 (R1)
Sunday, October 21, 11:00 - 12:15, Fairway 3 (R2)
Session ID: 18 |
 |
Gone are the days when we can develop an application using Visual FoxPro alone. Users today are much more sophisticated and expect to be able to use their favorite tools from within the application when it is appropriate. More and more applications are exposing much of their functionality through components which can be automated and this includes QuickBooks. Your users will thank you for realizing that their time is valuable too when you can automate QuickBooks and make sure they never again have to enter the same data twice.
In this session, you will learn how to:
- Download, instantiate and use the QuickBooks COM component
- Add vendors to QuickBooks using QBFC
- Add bills to QuickBooks from Visual FoxPro
- Add bill pay checks to QuickBooks
|
Presenter: Marcia Akins
Level: Intermediate
When: Friday, October 19, 1:15 - 2:30, Fairway 1 (R1)
Saturday, October 20, 11:00 - 12:15, Fairway 2 (R2)
Session ID: 24 |
  |
It has often been said that good programmers are lazy. It's not so much a question of being lazy, but more a question of making the most of your available time. Any tool that helps you to automate the trivial repetitive tasks that go along with the brain work of programming gives you more time to be really productive on the complex portions of your application.
Little things mean a lot. Any tool that saves you 30 seconds on a each task that you repeat several dozen times a day can add up quickly. Saving 30 seconds, 240 times a day effectively adds 2 hours of time to be productive to your day.
This session teaches you how to:
- Create a startup program to help you navigate quickly from project to project
- Use utility programs to automate repetitive tasks, such as inserting LOCAL declarations and typing field lists into SQL SELECT statements
- Use IntelliSense scripts to save time
- Use Report Builder extensibility to make creating reports faster
- Customize the VFP Edit Property/Method dialog to maintain allow a "remove from favorites" option and a way to remove member data when a property or method is deleted (among other things)
|
Presenter: Rick Borup
Level: Beginner
When: Friday, October 19, 4:15 - 5:30, Fairway 1 (R1)
Sunday, October 21, 9:30 - 10:45, Fairway 1 (R2)
Session ID: 8 |
|
In the same way design patterns provide a structure to help you solve common design problems, frameworks provide a structure to help you build a complete software application. Most applications share a number of things in common: menus, forms, toolbars, methods for rendering reports, retrieving and updating data, etc. A framework provides a standardized structure for these components and a standardized approach to managing the interactions between them. Whether you intend to use a full-featured commercial framework or just want to create a simple one of your own, understanding what a framework is and what it's intended to do will help you become a better developer.
In this session, you will learn:
- Concepts for framework development
- How to construct a menu manager
- How to construct a forms manager
- How to construct a reports manager
- How to tie these and other elements together into a working application<
|
Presenter: Rick Borup
Level: Intermediate
When: Friday, October 19, 11:00 - 12:15, Fairway 2 (R1)
Saturday, October 20, 8:00 - 9:15, Fairway 2 (R2)
Session ID: 20 |
|
Hanging out your own shingle as an independent developer can be the scariest yet ultimately the most rewarding experience of your career. What things should you consider before making this momentous decision? Once you've done it, what steps can you take to help ensure success? (Hint: writing good software is not enough!) In this session, Rick Borup brings real-life experiences from fourteen years as an independent developer to help those thinking about or already embarked on the exciting and challenging journey as an independent developer.
This session shows you:
- How to attract and retain customers
- How to estimate projects, set prices, and get paid for what you do
- How to manage, meet, and exceed customer expectations
- How to determine what business you're really in
- Basic financial management for the independent software developer
|
Presenter: Craig Boyd
Level: Advanced
When: Friday, October 19, 8:00 - 9:15, Fairway 4 (R1)
Saturday, October 20, 2:45 - 4:00, Fairway 3 (R2)
Session ID: 5 |
|
ClickOnce is Microsoft's newest application deployment technology. It aims to make deploying and updating applications as easy as point and click from the user's perspective, and as easy as deploying a web application from the developer's perspective. It does a pretty good job of both. We all know the hassles associated with deployment and issuing updates: creating loaders, generating installs, versioning, burning CDs, walking users through installing or updating applications. The list goes on and on. ClickOnce can help alleviate many of these headaches. This session will show you how to create a very small .NET assembly (essentially a single line of code) that can be used in conjunction with your Visual FoxPro applications to enable you to deploy using ClickOnce. Don't limit your deployment strategies and frustrate your users by continuing to use the old Microsoft Windows Installer technology. Come to this session and let your users just ClickOnce.
In this session, you'll learn:
- Why ClickOnce is a revolution in application deployment.
- How Visual Studio 2005 can be employed to deploy Visual FoxPro applications with ClickOnce.
- Where and how ClickOnce deploys an application and what all the moving parts of this new technology are.
- How to create a custom Prerequisite that handles the Visual FoxPro runtimes.
- How to update deploy Visual FoxPro applications with ClickOnce.
|
Presenter: Craig Boyd
Level: Intermediate
When: Friday, October 19, 11:00 - 12:15, Fairway 3 (R1)
Saturday, October 20, 9:30 - 10:45, Fairway 4 (R2)
Session ID: 25 |
 |
Regular Expressions are simply strings and yet they can provide a developer with unrivaled abilities to parse, search, validate, and replace data. What could take you a hundred lines of code to accomplish; regular expressions can allow you to do in one. Attend this sessions and I'll give you a solid grasp on Perl-style Regular Expressions as well as many real world uses for them in Visual FoxPro applications. Both the VBScript RegEx object and the more advanced RegExp.fll will be explored in-depth. Whether your applications need to simply validate email addresses or parse complex XML, this session will provide you with a powerful programming tool that gets the job done.
In this session, you'll learn:
- What Regular Expressions are and how to write them.
- How to parse, search, validate, and replace Visual FoxPro data using Regular Expressions.
- How to use the VBScript RegEx object and the RegExp.fll
- Why a simple cheat sheet is all you need to be a Regular Expressions expert.
|
Presenter: Mike Feltman
Level: Beginner
When: Friday, October 19, 2:45 - 4:00, Fairway 1 (R1)
Sunday, October 21, 8:00 - 9:15, Fairway 2 (R2)
Session ID: 23 |
|
Errors occur within every application. Even the most carefully crafted code may fail under adverse conditions. VFP provides a number of ways to deal with errors in our applications. Among these are the ON ERROR command, the Error method and TRY/CATCH error handling. Each method of error handling has its strengths and weaknesses. Luckily, with VFP developers don't have to choose between the various means of handling errors, instead, we can use all of them. In this session we'll look at the types of errors that can occur in a VFP application, the various ways of trapping errors in an application and the interaction between each of the methods of error handling.
|
Presenter: Toni Feltman
Level: Beginner
When: Friday, October 19, 2:45 - 4:00, Fairway 2 (R1)
Saturday, October 20, 2:45 - 4:00, Fairway 2 (R2)
Session ID: 13 |
 |
I've been a fan of DBI Technologies for a long time. They have a well-deserved reputation as providing the best VFP support from an ActiveX control vendor. With Sedna, DBI has really outdone themselves. Sedna includes 7 full-blown ActiveX controls from DBI at no additional charge.
In this session we'll take a look at each of these controls and how they can be used from within VFP.
You'll learn:
- How to use each of DBI ActiveX Controls
- The key properties, events and methods of each ActiveX Control
- Where appropriate, how to bind data to each ActiveX Control
|
Presenter: Toni Feltman
Level: Beginner
When: Friday, October 19, 9:30 - 10:45, Fairway 1 (R1)
Saturday, October 20, 11:00 - 12:15, Fairway 1 (R2)
Session ID: 29 |
|
Prior to Visual FoxPro 3.0 we all wrote procedural applications. When possible, we tried to write small generic code modules that could be reused and we were able to build very robust applications quickly. Then, along came Visual FoxPro 3.0 and object oriented programming. This type of programming is very different from what we were used to and many developers had a hard time becoming comfortable in this environment. This session is designed to simplify many of the concepts of OOP such as Inheritance and Polymorphism and make any developer feel comfortable programming it this type of environment.
In this session, you'll:
- Learn simple definitions for all of the major OOP concepts such as Class, Inheritance, Encapsulating, Polymorphism, Event, Method and Property
- See each of the major OOP concepts (mentioned in #1) in action
- Learn the benefits and disadvantages of object oriented design and development
|
Presenter: Tamar E. Granor
Level: Intermediate
When: Friday, October 19, 11:00 - 12:15, Fairway 1 (R1)
Sunday, October 21, 8:00 - 9:15, Fairway 1 (R2)
Session ID: 15 |
|
The Toolbox offers a marriage of the Form Controls Toolbar and the Component Gallery. In this session, we'll dig into this new tool and show how to use it effectively. You'll learn how to organize your classes, how to specify what's displayed at any time, and other tricks for customizing the Toolbox.
This session teaches you:
- Use the Toolbox to add controls to forms and classes
- Create custom categories to organize the Toolbox
- Add your own classes to the Toolbox
- Add text and scripts to the Toolbox to simplify development
- Set properties automatically as you add controls to forms and classes
|
Presenter: Tamar E. Granor
Level: Intermediate
When: Saturday, October 20, 9:30 - 10:45, Fairway 1
Session ID: 26 |
|
A realistic test data set provides a variety of advantages to developers, testers and end users, yet most applications don't include one. In this session, we'll look at the reasons for supplying test data and examine ways to generate it and you'll learn:
- Why every application should have a test data set
- What test data should look like
- About applications that create test data for you
- How to create your own test data using VFP
|
Presenter: Doug Hennig
Level: Beginner
When: Friday, October 19, 9:30 - 10:45, Fairway 2 (R1)
Sunday, October 21, 9:30 - 10:45, Fairway 2 (R2)
Session ID: 3 |
|
While a vertical market application shares many of the same goals as a custom application, the bar is higher because the audience is both larger in volume and broader in scope, plus you usually have much less direct contact with the customer. This session examines some of the things to consider when designing and implementing a vertical market application, including application licensing and activation, application maintenance models, and version update mechanisms.
This session discusses:
- Application licensing and activation: the pros and cons of licensing your software, licensing and activation tools, and online activation
- Application maintenance models: the pros and cons of subscription vs. pay-as-you-go updates, how to decide who is eligible, subscription management
- Version update mechanisms: manual vs. automatic update notification and installation
- Support policies: the pros and cons of different types of support delivery and policies
|
Presenter: Doug Hennig
Level: Intermediate
When: Friday, October 19, 4:15 - 5:30, Fairway 4 (R1)
Saturday, October 20, 11:00 - 12:15, Fairway 4 (R2)
Session ID: 7 |
|
Windows Vista changes the rules for many aspects of application development, including the user interface, dialogs, deployment, security, and file access. This session looks at things you need to know to create Vista-compatible applications with Visual FoxPro.
In this session, you'll learn:
- Why your application can't run as administrator any more
- How Vista's User Account Control impacts your application
- Changes your installation executable needs to work properly
- Taking advantage of new Vista dialogs
|
Presenter: Whil Hentzen
Level: Intermediate
When: Friday, October 19, 1:15 - 2:30, Fairway 4 (R1)
Sunday, October 21, 11:00 - 12:15, Fairway 4 (R2)
Session ID: 12 |
|
In 1994, I reviewed Robert Green's Client-Server Applications with VFP book for the second Pros Talk Fox series. Thirteen years later, one would think that everyone and their brother (and their sister) has written a client/server application. Au contraire! While writing MySQL Client/Server Applications with Visual FoxPro this year, I found that there are large numbers of folks who have never touched any client/server tools, but are, for one reason or another, now anxious to do so. So join the crowd!
In this session, we'll build a basic client/server application using VFP and the open source database engine MySQL. The pair make a great combination, powerful and hugely scalable, with nary a client-access license or fee in sight. We'll start out discussing the concepts that differentiate a native-DBF application with a client-server system. Then we'll look at the interactive use of VFP in connecting to a back-end and discuss the plumbing involved. Finally, we'll build several typical forms and show how they differ from the typical user interfaces you may be used to building in DBF-style systems.
|
Presenter: Whil Hentzen
Level: Beginner
When: Friday, October 19, 4:15 - 5:30, Fairway 2 (R1)
Saturday, October 20, 2:45 - 4:00, Fairway 4 (R2)
Session ID: 21 |
|
There are thousands, no, tens of thousands, no, hundreds of thousands of Fox applications out there. Unfortunately, there aren't hundreds of thousands of Fox developers any longer, and more likely, the original developer is one of those long gone. The application is now - potentially - yours. But this situation is often fraught with peril.
Along with those hundreds of thousands of applications come hundreds of thousands of different approaches to building them. As a result, there isn't a single recipe for approaching an inherited app. The best we can do is offer some ideas from which you can choose from those that make sense for your situation.
In this session, we'll first take a look at what to do when you're presented with "We have an application we'd like you to look at. Oh, and by the way, the original developer isn't here any longer." While there are technical challenges a-plenty with vintage applications, the bigger struggle will be the customer interface - determining what expectations should be, and then setting those expectations for your primary contact.
Once you've decided to take on the job, it's time to look at the technical side of things. We'll make some suggestions on how to quickly and efficiently grok a system that has landed on your shoulders, again using examples from real life situations whose names have been changed to protect the innocent.
|
Presenter: Michael Hogan
Level: Intermediate
When: Friday, October 19, 9:30 - 10:45, Fairway 3 (R1)
Sunday, October 21, 8:00 - 9:15, Fairway 4 (R2)
Session ID: 1 |
|
Data changes: fields required for different types of records may differ. When different records within the same table require one-to-one joins with different child tables or when a table gets bloated with mostly unused fields, it's time to consider a more efficient way of handling the supplemental data. A contacts table might contain employees, consultants, companies, salespeople and family and friends, each record type having its own supplemental data field needs. Do you end up with 150 seldom-used fields to keep it all straight or perhaps a half-dozen related tables (one for each record type)?
XML to the rescue! Using VFP’s CursorToXML and on-the-fly cursor structures you can encapsulate that data in memo and varchar fields.
This session will teach you:
- Avoiding table bloat from rarely-used fields in their tables
- Saving and extracting phantom sub-tables within memo and varchar fields
- Using different sub-table structures for different record types within the same table
- Memo to Object and Memo to Cursor techniques and their corollaries
- When to use and not use this technique
|
Presenter: Andy Kramek
Level: Beginner
When: Friday, October 19, 8:00 - 9:15, Fairway 1 (R1)
Saturday, October 20, 1:15 - 2:30, Fairway 1 (R2)
Session ID: 6 |
|
When confronted with the task of designing a database most of us tend to start thinking in terms of tables and fields. This is, generally, a mistake. The reason is that before we can really start to design tables we need to understand the function of the database and to plan its structure. Getting this correct is crucial to building a good application because the database is the foundation on which applications are built. Like all foundations, if it is solid then the structure on top of it will be stable, but if it is unsound anything built on top of it will also be unsound. In this session we will look at some simple guidelines that, if followed, will help you when you next tackle the job of designing a new database.
While different database may implement things in slightly different fashions, the principles covered in this session apply equally to all relational databases, whether we are talking about VFP, SQL Server or Oracle.
This session will teach you how to:
- Recognize the different types of database and the implications for the design of each
- Create a paper model to validate the initial design
- Translate the logical design into a physical design by identifying the various types of data involved at each stage
- Differentiate between the various structural types of table and when to use each
- Differentiate between the various relational types of table and when to use each
- Define Database, Business and Validation rules and to implement them in the correct application layer
VFP 9 introduced a new beast called the ReportListener which gives you the ability to extend your reports beyond the native behavior. In this session you'll learn all about this animal and how to take advantage of it, and:
- How to run reports using a ReportListener
- What properties are available and what they can do
- What methods are available and what power they have
- About the ReportListeners provided with VFP
- Some cool tricks provided courtesy of custom ReportListeners
|
Presenter: Cathy Pountney
Level: Intermediate
When: Friday, October 19, 2:45 - 4:00, Fairway 3 (R1)
Sunday, October 21, 11:00 - 12:15, Fairway 1 (R2)
Session ID: 17 |
|
The Visual FoxPro Report Writer has great power, but sometimes you need to print reports slightly different than the native behavior. In this session I'll show you how to use the VFP ReportListener object, combined with API calls, to extend the way you print reports. You'll learn how to print from the previewer WITHOUT closing the preview window. You'll also learn many more techniques such as printing two pages per sheet so you can bind the report as a booklet.
This session teaches you:
- How to print on your terms
- How to print selected pages without closing the previewer
- How to print multiple copies, collated and non-collated
- How to print multiple pages on one sheet
- How to print booklets
|
Presenter: Steve Sawyer
Level: Beginner
When: Friday, October 19, 1:15 - 2:30, Fairway 2 (R1)
Saturday, October 20, 1:15 - 2:30, Fairway 2 (R2)
Session ID: 2 |
|
Marketing and selling your services as a builder of custom business applications presents some unique challenges. However, the basic principles of strategic planning and marketing can be applied to the problem. This session explores ideas in identifying your product, your market, and how to identify and sell appropriate prospects.
In this session, you'll learn:
- How high-technology startup businesses meet the marketing challenge - and how it applies to the software development business
- How to change your thinking about your business to improve your ability to market, sell and generate revenue
- How to define a viable market for your services
- How to define your product to appeal to your market
- How to reach potential customers
|
Presenter: Steve Sawyer
Level: Beginner
When: Friday, October 19, 8:00 - 9:15, Fairway 2 (R1)
Saturday, October 20, 9:30 - 10:45, Fairway 2 (R2)
Session ID: 22 |
|
Survival in a changing business environment requires flexibility and adaptability. Most project managers and technical middle managers lack the necessary hands-on software development experience to be truly effective as software project managers. Software development teams - both in-house and domestically or globally outsourced - are charged with short-term goals often at odds with long-term company needs.
Experienced software developers with the requisite business skills and experience can make significant contributions to the software development process as project managers.
This session teach you:
- How software development projects can achieve short-term success, yet fail to succeed in the longer term
- The role of data modeling in achieving a strategic advantage
- How to leverage the strengths and compensate for the weaknesses of software development teams
- How to facilitate software development by acting as a liaison between the technical team and the business owners
|
Presenter: Rick Schummer
Level: Beginner
When: Saturday, October 20, 8:00 - 9:15, Fairway 1 (R1)
Saturday, October 20, 2:45 - 4:00, Fairway 1 (R2)
Session ID: 19 |
|
There are many good reasons VFP developers decide to migrate their application data stores to a SQL Server back end. The migration presents different challenges from an architectural, implementation, deployment and support perspective. It also reveals the need for a new set of tools in the VFP developer toolkit.
Understanding what tools you need and where to get them can be overwhelming when you start your first SQL Server based project. Even experienced SQL Server developers and database administrators can use new tools in their toolkits. You can certainly get by with the SQL Server 2000 Enterprise Manager and Query Analyzer, or the newer SQL Server 2005 Management Studio, but you will find expanding your toolkit with other products will simplify certain things, and certainly improve your productivity.
This session will highlight various tool categories, list various products you might want to consider and review, and demonstrate why they are useful in your interaction with SQL Server during the development, testing, deployment and production support phases of your projects.
In this session, you'll learn:
- What is available to manage MSDE 2000 in the production environment
- Why using a CASE tool will simplify the database design phase
- How to compare and synchronize database schemas and content
- Easy ways to setup and manage backups
- Better ways to work with T-SQL code
- Why we loved Stonefield Database Toolkit with DBFs and if there is something similar in the SQL Server world
- How to interact with source code control
- Simplified database documentation
|
Presenter: Rick Schummer
Level: Intermediate
When: Friday, October 19, 1:15 - 2:30, Fairway 3 (R1)
Sunday, October 21, 8:00 - 9:15, Fairway 3 (R2)
Session ID: 28 |
|
The VFPX open source project on CodePlex is designed to create add-ons and tools VFP developers can use to develop custom solutions for their customers. The mission of VFPX is to extend Visual FoxPro by creating open source add-ons and to complement Microsoft's continuing efforts to improve and extend VFP via Sedna.
This session will introduce VFP developers to VFPX on Codeplex, and will demonstrate and show real world implementations of the various components and tools developed and under construction in VFPX. At the end of the session you can learn how you can get involved in the future of Visual FoxPro and why it is important to you as a VFP developer.
This session teaches you:
- Where to find VFPX tools and components, and how to use CodePlex to your advantage
- What tools and components are available to VFP developers
- Through live demonstrations of the New Property/Method Dialog box, ClassBrowserX and Code Analyst, VFPX projects make you more productive the first time you use them
- How to implement and demonstrate real world examples of the various components including ctl32StatusBar, Desktop Alerts, GDIPlusX, OOP Menus, the Outlook2003Bar, and more…
- How to get involved and contribute to this important effort in the Fox Community
|
Presenter: Alan Stevens
Level: Advanced
When: Saturday, October 20, 8:00 - 9:15, Fairway 3 (R1)
Sunday, October 21, 9:30 - 10:45, Fairway 3 (R2)
Session ID: 10 |
|
Microsoft has released two exciting options for including Windows Forms user interface elements in COM-based technologies such as VB6 and Visual FoxPro. These are the Windows Forms Interop Toolkit, and the Interop user control. The former allows VFP developers to display entire Windows Forms, while the latter enables the developer to display .NET controls within VFP forms through an ActiveX container.
While VFP forms are perfectly capable of providiing a user interface for today's business applications, these two new toolkits open up previously unavailable options. We will address controls in Windows Forms that are not available in VFP.
In this sesson, you will learn:
- The fundamentals of Windows Forms development
- How to build an interop form and display it from VFP
- How to build a Windows Forms user control
- How to include an interop user control in a VFP form
- How to bind to events on an interop control
|
Presenter: Rick Strahl
Level: Intermediate
When: Friday, October 19, 9:30 - 10:45, Fairway 4 (R1)
Saturday, October 20, 1:15 - 2:30, Fairway 4 (R2)
Session ID: 4 |
|
Find out and understand how to efficiently utilize VFP COM components from .NET and specifically ASP.NET. This session introduces the basics of creating a COM component and calling this component in a variety of different ways from .NET. Topics covered deal with basic use, passing complex parameters and using reflection for dynamic properties and methods, passing datasets, and dealing with .Net's type safety mechanisms as well as addressing COM debugging and performance issues in the .Net environment.
This session teaches you:
- The basics about ASP.NET Web Forms
- How to create COM Servers in Visual FoxPro
- How to call and access these COM Servers from .NET code
- How to deal with COM Interpol type translation issues
- How to pass in a variety of ways between Visual FoxPro and ASP.NET page code
|
Presenter: Rick Strahl
Level: Intermediate
When: Saturday, October 20, 9:30 - 10:45, Fairway 3 (R1)
Sunday, October 21, 11:00 - 12:15, Fairway 2 (R2)
Session ID: 14 |
|
AJAX provides the ability to create a richer and more intereactive client side experience for Web applications and there's been a big push in Web applications to incorporate this technology. This session takes a look at the technology, what it's good for and looks at a number of examples that let you use AJAX in combination with Visual FoxPro from using FoxPro based HTML generation on the server using standard mechanisms to turning FoxPro into a service style engine to service AJAX requests.
In this session, you'll learn:
- What Ajax is
- Why they might want to use it
- How it works on the HTML end
- How it can be integrated with Visual FoxPro
- What to watch out for when implementing AJAX
|
Presenter: Christof Wollenhaupt
Level: Advanced
When: Friday, October 19, 11:00 - 12:15, Fairway 4 (R1)
Saturday, October 20, 1:15 - 2:30, Fairway 3 (R2)
Session ID: 11 |
|
Microsoft is known to change technologies faster than the marketing department can print advertisement material. COM, however, is still the foundation for quite a few Microsoft technologies that are available today. A lot has been said about COM, even more complained, but hardly anyone really knows what COM is. This session attempts to cover COM not from a user perspective, but from its internals. What are interfaces? How does Windows load COM objects? What happens when you call a method? Why do so many things work, but other things don't? What are apartments and who cares about the threading model? What's the difference between thread and process, EXE, DLL and MTDLL, early-binding and late-binding, between VTable and IDispatch? This session requires basic knowledge of memory addresses, pointers and data storage.
In this session, you will learn:
- How COM really works
- The meaning of many acronyms
- How to decide what COM technology to use
- How understand problems when using COM
- How to use COM with .NET
|
Presenter: Christof Wollenhaupt
Level: Intermediate
When: Friday, October 19, 2:45 - 4:00, Fairway 4 (R1)
Sunday, October 21, 9:30 - 10:45, Fairway 4 (R2)
Session ID: 16 |
|
Visual FoxPro is a lot: it's fast, productive, stable, amazing, surprising... but it certainly isn't logical and consistent. Over more than two decades with three fundamentally different programming concepts, four operating systems and two compilers left their traces in the product we love. FoxPro as a high-level development tool doesn't require knowledge of the internals; much less than .NET. But should you encounter problems it's helpful to know a bit about what's going on behind the scenes. This session covers the internal management of variables, memory management, the handling of classes, objects and containers (and why those are the same, yet completely different), the system datasession, the impact of cache, buffers and transactions, table access, Rushmore optimization, and so on.
In this session, you will learn:
- How variables are managed
- How memory and buffers are managed
- How VFP deals with objects
- How to avoid problems with a buffer
- What to consider with Rushmore
|
Presenter: Christof Wollenhaupt
Level: Beginner
When: Saturday, October 20, 8:00 - 9:15, Fairway 4
Session ID: 27 |
|
The interest in version control systems has steadily increased during the past decade. So far, Microsoft Visual SourceSafe has been the tool of choice for many developers. However, if you start using version control systems now, you might want to look into alternatives.
CVS and Subversion are powerful, client/server based version control systems. Being open source you can't beat the price. In this session you learn how to install, configure and use these tools in Visual FoxPro. We will cover different approaches of integrating them into the VFP IDE. We also talk about the conceptual differences between Visual SourceSafe and CVS/Subversion.
This session teaches you:
- Why source control is really useful
- That source control doesn't have to be expensive
- How to use CVS
- How to use SubVersion
- How both compare to tools like Visual SourceSafe
|
|