[Deutsche Vorträge] [Englische Vorträge]
Application Development: Anatomy of the Visual FoxPro Development Cycle
Andrew Ross MacNeill
Melton Technologies Inc.
Take a peek inside the development of a Visual FoxPro application. There are a lot of new concepts and ideas that need to be considered as well as pitfalls and traps. Using the example of a transaction-based event-driven system, the session describes the building blocks of OOP as they are used in building an application framework. This is not a session about theory but about how to apply the OOP theory in practice and business development.
The application being designed is still in development - its not finished by any means. However it is nearing the final stages and has been released into a limited beta with its particular customers. Is this session the final word on VFP development? No but it offers a guideline of one applications development cycle.
Many sessions cover the theory of application development. This session goes into a detailed description of the problems encountered in building an application in the initial version of Visual FoxPro. The application in question is an event-driven system, using the concept of events as transactions within a business system. Before the application was started, a lot of thought went into what could be tried with Visual FoxPro. A lot of this discussion took place during the beta and therefore couldnt be realized in the final product. This session talks about things that worked and things that didnt so as developers, you dont need to make the same mistakes when working on your first, second or third application.
Advanced OLE Automation
Andrew Ross MacNeill
Melton Technologies, Inc.
This session is not an introduction to OLE; rather, it is geared towards using OLE Automation to further application development. OLE Automation can be used for more than passing calculations through Excel or writing Word documents; OLE Automation can completely redefine the types of applications developers build and the way they build them.
These session will focus on a wide variety of OLE Automation controls as well as two powerful tools, Microsoft Project and Visio as examples of advanced OLE Automation. Samples shown in the session will include building class diagrams with Visio and project plans with Microsoft Project. Also discussed are the different ways integration can work: hidden, where the automation server lies hidden on the users desktop or; visual where the OLE object has a graphical entity that the user can "look & feel".
The BOSS and FoxExpress 2.6
The BOSS is an application that was created using FoxExpress 2.6. It also happens to be the in-house application that Neon Software uses to perform day-to-day operations. The beauty of The BOSS is that, while it is a fairly complex application, it was developed completely using FoxExpress 2.6. The purpose of this document is to take a look at how The BOSS was created.
In creating The BOSS we had needs that were specific to how we run the business. For example, there are times when we need to do mass mailings based on categories of customers. Another example is our need to track when we ship a software product, such as FoxExpress, to our users. Because of some of these needs, we added additional features to the application that could not be generated with FoxExpress. Lets take a look at how we addressed these specific needs using FoxExpress.
Creating a Successful FoxPro Product
Micromega Systems, Inc. S.F. CA.
Good ideas are plentiful
If you're a developer, it's likely that you think of good ideas faster than you can do anything with them. It's also likely that you've had at least one idea for a "million dollar" product during your career. Maybe it was a clever utility you wrote to help your client with some problem, or perhaps it was a new vertical market application that you thought of while talking to a prospect. The temptation to create a product is strong and inbred to programmers. And from personal experience, I promise that if you decide to go ahead, it will be one the most exciting, frightening, educational, and rewarding experiences you've ever had -- even if you go broke in the end.
Bringing an idea to market is difficult and risky
This discussion will cover some important points for turning your idea into a product, including potential and actual problems, traps, tricks, and rewards of doing so. We will begin by briefly reviewing my experience which includes some failed attempts at creating a product (this history illustrates not just to how easy it is to fail but also provides insight about my current point of view.
The last case study will be the inside story of Foxfire! Report Writer, my first really successful FoxPro add-on product. We will study some important lessons that Ive learned from my efforts, and I will make observations and recommendations that may help you avoid some problems. Finally Ill answer individual questions and you are most welcome to contact me during the conference (Ill be in the Foxfire! booth) or by email later at firstname.lastname@example.org.
Early warning -- your two biggest traps
I want to caution you about the two biggest pitfalls a programmer faces when trying to create a product:
1. Out-thinking your potential customer (we call it overly-intuitive thinking) which leads you to false conclusions and wrong-headed thinking, and
2. getting distracted by other ideas.
These two factors come from inside you and are at the core of most of the unsuccessful products Ive studied. By the way, Im not immune to them. See if you can identify them as we proceed.
Using VFP objects, C++ objects and the Library Construction Kit
Visual Foxpro 3.0 brings the power of OOP to xbase. You've all heard that before, but what does it really mean? What is OOP and how can you take advantage of it? You have a boatload of existing customers using your Foxpro applications. How can you migrate easily to the new way of thinking?
Advanced Client Server
Matison Consulting Group
This session will look at several issues that arise when developing client server based applications using Visual FoxPro. The examples in this document use SQL Server as the back end but the concepts are applicable to most client server systems. We start by defining the problems faced when using optimistic vs. pessimistic buffering. This discussion is then extended to include the issues faced by notebook users or sites that only periodically exchange information with a host.
Finally, a technique for implementing lists used for lookup purposes is developed. This technique is applicable to workstations connected to the server through a local connection or by dial up access.
Database Maintenance and Integrity
In the past, the issue of database design in the PC environment has been very much neglected by both the developers of database applications and by the providers of development tools. There are many reasons for this. Due to the hardware limitations in processing power as well as disk space, developers developed database applications which were necessarily small and simple for use by a single user. Well aware of the hardware limitations, customers were neither demanding nor sophisticated. They were prepared to computerize only a small segment of their business without going into every detail and without really knowing for what to ask. As they could not have an ambitious information system containing 100% of all relevant information, they settled for very small databases containing few tables.
Because the databases were small and simple, providers of PC development tools focused on the programming language, compilers, linkers, and tools to enhance the user interface rather than on providing development tools for the design and maintenance of the database. As a result, databases were not only not given the proper attention by providers of development tools, but databases were not given the proper importance by developers who understood that their task was to develop applications for their clients, disregarding the fact that data is the raison dêtre of their applications
Building Applications Using Class Libraries
Toni M. Taylor-Feltman
At the heart of Object Oriented Programming are class libraries. Class libraries are the building blocks of all object oriented applications. Visual FoxPros class designer gives developers the tool necessary to create these "building blocks." Creating applications from class libraries results in more easily maintained applications.
This session focuses on how class libraries will help us create better applications, faster. Class libraries are more than just a group of objects that are dropped on a form. They are the nucleus of all applications. We will explore how to design reusable class libraries that can be utilized throughout the application development cycle. The applications we create will be easy to maintain and enhance. You will be able to leverage the class structure in every application you create. With the right set of tools, building an application becomes a "plug and play" job. At the same time, maintenance becomes a breeze.
In order to gain the most from this session, we are going to look at a very simple example that that may look familiar to you. The example is EX1 that shipped with FoxPro 2.x. This example uses some obsolete features from FoxPro 2.x, such as the foundation read, however, it is a simple example of how most applications work. We are going to build an example very similar to EX1 using class libraries, while looking at each of the objects that make up the application. Then we will explore how easily the application can be modified and enhanced
We will start with a short introduction to the principles of Properties, Events and Methods. You need to know these terms to work with controls of any kind. The main part is a guided tour through all Controls. We will visit old, new and changed ones in a sorted order - walking all properties upstairs. The controls are sorted by the number of properties, events and methods they have bringing us some new of each by each new control we see. Finally we will share some words about containers, naming conventions and the use of Builders as well as guide you to some sessions that build on this one.
Extending the Visual FoxPro Database Container
For years, FoxBase and FoxPro developers have realized the need for a central storage location for information about the tables used in our application, or in other words, the need for a data dictionary. For years, FoxBase and FoxPro have lost points in countless reviews because of the lack of this feature. For years the third party market has been flooded with many viable solutions to this problem. Products like Tom Rettigs Office, Stonefield Data Dictionary, Foxfire! and FoxExpress, that have been available since FoxPro 2.0 or earlier, all are either specifically a data dictionary or gain much of their functionality simply from the mere existence of a data dictionary in the product. Finally, with the release of Visual FoxPro, Microsoft has shown us that they too have recognized this need and thus theyve given us the Visual FoxPro Database Container.
The Database Container (DBC) is one of the most wonderful new features of Visual FoxPro. The DBC provides us with a convenient location for storing business rules, views and other information that governs the use of data within our applications. Most importantly, because the DBC is a native piece of FoxPro, it provides something that only Microsoft can provide, ties directly to the our business rules at the engine level. Before Visual FoxPro, even the most powerful and sophisticated data dictionaries for FoxPro could only insure the integrity of your data from within an application and even then, the application had to have hard coded references to the data dictionary to accomplish this.
As wonderful as the DBC is, it still leaves much to be desired, and it is not a data dictionary. Although the DBC provides many features in a more elegant fashion than a third party product could possibly provide, in many areas it doesnt even begin to approach the functionality offered by some of its third party predecessors. What the DBC does provide is a starting point for Data Dictionary features and a logical location for the integration of these features with the FoxPro environment.
Using OO effectively: An Introduction to Object Oriented Development
Micromega Systems, Inc.
I'll admit it -- getting acclimated to the world of objects is a shock. Not since the advent of structured programming has a solution been so highly touted as The Answer for the many problems of crafting software. With the advent of Visual FoxPro, I'm sure you're hearing nearly everywhere that Visual FoxPro has vaulted to the leading edge of application development toolsets.
Now don't get me wrong -- OOP is certainly new to even the most experienced and GENSCRNX fluent FoxPro developer. It is one of the most exciting new technologies to enter the sphere of application development since the PC.
Maybe you're also just a little fearful, as well. For this new FoxPro represents a radically different approach to building applications. It is without a doubt the largest leap from a prior version we've ever seen in Xbase. How are you going to absorb it all? Just how soon can you get productive with the new environment? What if you make a disastrous architectural mistake that forces you to rewrite your first big VFP project? Or worse, makes you say something at a user group or on the Foxforum that makes you appear naive? Being a little intimidated is certainly understandable.
This session is intended to help FoxPro developers new to the object oriented mindset make the transition to working with object most effectively. It explores detailed techniques as well as some of the "big picture" perspectives which I hope will help you get the most bang for your buck with object development.
Introduction to Object Orientation
Microsoft MVP 1993, 1994, 1995
Object Orientation is an approach to the analysis and design of software systems which involves the identification of self contained components which can be linked together to produce complete applications. These components achieve the encapsulation of data and function, the ability to inherit things from other components, and can communicate with each other by sending messages back and forth.
Debugging and Error Handling in an Object-Oriented Environment
Lisa Slater Nicholls
VFP will make some changes in the way your applications handle errors, and the way you cope with them during development, too. This session will concentrate on code strategies to log and respond to errors in applications. It will also take a look at the FoxPro debugging tools to see how they "react" to the changes in the Fox language and event model. We'll emphasize:
Event Driven Programming in Visual FoxPro
Visual FoxPro's new event model, combined with the robustness of the object model and the addition of many new events, allows truly modeless programming with far finer control of the behavior of your system. The Foundation Read has been replaced with two simple commands to hook your application directly into FoxPro's native event loop. New events are available to programmers with exciting implications for application development.
Visual FoxExpress is an Application Wizard for Visual FoxPro. FoxPro supplies wizards that help developers create individual pieces of an application. An application wizard is basically a collection of wizards that create the various components of an application, screens, reports, programs, queries etc. Unlike standalone wizards, the individual wizards in this collection of wizards know how to communicate with each other. In other words FoxExpress wizards not only create individual components, they also automatically integrate the items they create into your application. For example, when a form is created in FoxExpress, FoxExpress takes care of adding the form to the menu or calling form, and either adds toolbar options directly to the form or automatically coordinates the form with your applications toolbar.
FoxExpress quickly became the leading RAD tool for FoxPro 2.6. Theres really only one reason for this - no other product has ever managed to combine power, ease of use, elegance and simplicity in quite the same fashion as FoxExpress! The challenge we faced in developing VFE is to continue with this tradition while tapping all of the power of Visual FoxPro.
In order to do so, we worked with other industry leaders at Flash Creative Management and Micromega Systems. Visual FoxExpress is based on the Codebook class libraries and design methodologies. In fact, Visual FoxExpress includes a copy of the Visual FoxPro Codebook.
In other words, when you create an application using Visual FoxExpress, Visual FoxExpress uses the class libraries found in the Visual FoxPro Codebook as a starting point. In many ways Visual FoxExpress can be considered an interface to the Codebook methodology. In most cases, we have extended the Codebook classes to provide a great deal of additional functionality. For example, weve extended the Codebook Form Object classes to automatically take advantage of DBCX, there are many additional form and business object types, Visual FoxExpress supplies powerful tools for querying tables and locating records, there are additional toolbar and menu options not found in Codebook, the report management classes can have complex query forms associated with them and much more.
Beyond Ad Hoc Reporting: Getting Results with FoxFire!
Micromega Systems, Inc.
The steps involved in transforming a set of information-based requirements into an application that genuinely solves a set of business problems have been described for over twenty years. Despite numerous theories and technologies set forth to streamline the process and improve the result, the real-world practice of application development is still largely unimproved upon:
Alan C. Schwartz
Micromega Systems, Inc.
The form designer puts the Visual in Visual FoxPro. It is the focal point for constructing not only forms (the new MS term for screens or formats), but toolbars and visual classes as well. Developers will find it contains:
This session tours the form designer from the application developers perspective. Our goal is to help you assess how it will impact your development style and your plans for building projects in Visual FoxPro.
Having fun with OOP
When developing your Visual Foxpro applications, never use the VFP baseclasses directly. Subclass all the baseclassses, and use those subclasses. Eventually, you may want to add some new capability to your applications. For example, you might have an application already deployed, and you just learned how to make all your forms dynamically resizable by the end-user. All you need to do is modify your subclass, and all your applications will inherit the new capability. You can add your Visual Class Library (VCX) with all your subclassed controls into the Project Manager, and when you're designing your forms, you can drag and drop the controls from the project right onto the form.
The Grid Control
Lisa Slater Nicholls
The Grid Control has been described as "BROWSE on steroids". But is the Grid just a more-powerful, less-painful BROWSE? This session covers the Grid control and its component objects (columns, headers, and contained controls). We'll discuss the relationship of Grid and Browse, and how you can manipulate Grid's appearance, relation to data, and its special events and methods, to achieve the results your applications need.
The heart of this session is found in its source codes, so you'll find that the accompanying session notes are relatively short.
Please be sure to run LSN_DEMO to check out all the Grid examples and to investigate the accompanying files. These notes will merely point you in the direction of the "goodies" you'll find there.
Menus, GENMENUX & Beyond
Andrew Ross MacNeill
Melton Technologies, Inc.
Since 1984, graphical interfaces have introduced developers to new terms and concepts: windows, icons, mice, toolbars, the list goes on. The graphical interface also refined a lot of steps in the application development process by introducing standard ways of presenting information. Tabbed dialogs are becoming increasingly popular as are floating toolbars. Many of these new items suggest that menus arent needed anymore. Many developers try to get rid of their menus by having every function in an application on a toolbar. But menus are necessary for two important reasons:
OLE Custom Controls in VFP
Steven M. Black
Support for OLE Custom Controls is one reason why Visual Basic developers are so keen about their platform. Visual FoxPro now joins the fray! In the months ahead, Custom Controls should transform the FoxPro third-party market. In this session, we will examine how to use Custom Controls in VFP, look at what the Custom market might bring us, and along the way develop a few working examples.
On the VFP Form Controls toolbar, we find two OLE Control buttons. One is for the OLE Container Control, and the other for the OLE Bound Control. The OLE Container Control is used to hold Custom Controls, while the OLE Bound Control is used to link a form to a General field. In this session we focus primarily on the OLE Container Control.
Introduction to OLE Automation with Visual FoxPro 3.0
OLE is a technology in the Windows world that allows the inclusion of an object or document from one application in another application. The application that "owns" the object or document is called the Server while the containing application is called the Client.
For example, a Microsoft Word document may contain a Microsoft Excel spreadsheet, in this scenario Microsoft Word is the client and Microsoft Excel is the server. In OLE version 2.0, when the user tries to edit the spreadsheet, Excel will take over the menu and the toolbar but the user will still feel that they are in Word. This is called In-Place editing.
Visual FoxPro complies with OLE 2.0 standards. Another feature of OLE 2.0 is OLE Automation. OLE Automation allows us to program the OLE object as if it were just another object in our application. Each OLE server will expose different methods and properties to the client, we can use these methods and properties to control the OLE server and thereby modify the OLE object.
Pattern Implementation in VFP
Steven M. Black
This is an overview of selected object-oriented design patterns, and how to build them in Visual FoxPro. The patterns exposed here are:
At the outset, the goal of this paper is to introduce implementations of object oriented design patterns to the FoxPro community. Hopefully it will serve to stimulate some productive discussion. Why? Three reasons: Firstly because patterns help us illustrate object usage and programming style. Secondly, understanding the give-and-take among patterns helps to avoid silly tactical mistakes. Third: knowledge of how design patterns work together is a pre-requisite to become an architect in any field!
Pattern language is a vast topic, and much of it is beyond the scope of this paper. We wont dwell on many significant aspects of pattern semantics. Suffice here to say that software patterns exist, here are a few of them, and heres how to rig them in Visual FoxPro.
Want to learn more on object-oriented design patterns? A bibliography, interesting reading, is included near the end of this document. In fact, this paper arises because a common question I hear from colleagues is "These are evocative concepts, but how can I implement these designs in Visual FoxPro?"
ProMatrix Application Wizard
Joseph E. Lawson
ProMatrix revolutionizes the development of professional FoxPro applications. With ProMatrix you can create a powerful FoxPro application in a fraction of the time it would take to create the same application on your own. Some developers find that ProMatrix cuts their application development time by more than 90%.
This presentation provides an overview of how ProMatrix reduces development time and makes applications more powerful. It describes how ProMatrix organizes and automates the creation of professional FoxPro applications. We will be demonstrating the capabilities of both ProMatrix for FoxPro 2.6 and our new Visual ProMatrix for Visual FoxPro 3.0.
Our presentation will end with a description of how ProMatrix for FoxPro 2.6 was converted to Visual ProMatrix. We will point out what we have learned about converting FoxPro 2.6 applications to Visual FoxPro 3.0 in the hope that you will benefit from our experience.
The Builder Builder's Reference
Steven M. Black
Great news from VFP comes from how the Class Designer (cd) and the Form Designer (fd) interact with the development environment. All Visual FoxPro objects are endowed with both design-time and run-time manifestations and public interfaces.
Custom programs, written in FoxPro, can manipulate our design-time work. For the first time support for this sort of thing is built into the language. And it's extensible, because the architecture is open. This has really profound implications.
[Deutsche Vorträge] [Englische Vorträge]