The German Visual FoxPro Developer conference is organized by the German FoxPro User Group. It is the main event for Visual FoxPro in Germany, Austria and Switzerland since 1994. 2006 is the 13th anniversary - as always in early November and again with UT-online coverage. Instead of increasing the number of available sessions even more we decided to decrease the entry fees! International Speakers present in different sessions. Another set of sessions are offered in our special Tracks for a total of 4 dozen English sessions. On all four days of the conference you can choose between different English session in every row of the session plan.

Date:
Location:

This conference has 158 pictures. We display 12 randomly selected pictures here. You may click here to view the album thumbnails.

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

German VFP DevCon 2006

• Day Zero
• Thursday, November 9
• Friday, November 10
• Saturday, November 11

Day Zero

by Jan Vít and Jan Král

Mission Possible - Prague: 6:00 PM

As we were approaching the German border, we realized, this might actually be the right time to get a map. So we stopped and Jan told me to go and find some good map. After 10 minutes I found a map and paid for petrol as well. That would not, of course, be a problem if my credit card had worked properly. Ohhh, computers! Fortunately I had a second card. Rest assured, we refueled, had a little snack and passed the border without any other significant problems. As a precaution, we spent a few following minutes discussing various possible car accidents such as a punched tire in the speed of 140 km per hour and their unpleasant consequences.

As time was passing by, we were getting closer and closer to Frankfurt. I started to play with a nice thought to get a little rest, but do you remember what I told you about the driver? Yes, then you know I finally decided to stay awake on alert. When Jan told me that we are beginning to be a bit behind the schedule and consequently stamped on the accelerator, I didn’t hesitate for too long, carefully fastened my seatbelt and started finding my notes from today’s first aid lesson. You wouldn’t believe how easily I refreshed my memories!

If I am to be completely honest here, I have to admit that not everything was the drivers fault. I don’t know why, but somehow I thought it might be simpler to drive to Frankfurt through Heilbronn. Even though Jan did not share my opinion and wanted to drive through Würzburg, I used all my powers of a navigator and persuaded him to take the route I have chosen. Later on it begun to be obvious that Jan was right. I however still tried to reason my former decision in any way possible. As a last resort I tried to argue about having an opportunity to see a beautiful landscape around Heilbronn, but when Jan pointed out there is, of course, nothing to see at night, especially when we are tired and it is around 1AM, I ran out of arguments. Be it night or day we certainly got a chance to view Heilbronn at night, if only from a highway circle around the city.

In spite of the fact that I am probably the worst navigator in the world, Jan still wants me to get some practice while navigating so this seems to be the end of my writing today. We are looking forward to see everyone at the conference and certainly looking forward to have a great time there. Should you not find any report here tomorrow, we are probably still somewhere lost, trying to find our way to the conference hotel. See you there!

Thursday, November 9

by Jan Vít and Jan Král

Welcome to the 13th dFPUG Microsoft Visual FoxPro DevCon!

Reading these lines suggests that we have indeed arrived safely to the hotel and that we are ready to provide you with the up to date online coverage of this magnificent event.

Apart from the Visual FoxPro DevCon, there is also an SQL-Server & .NET DevCon conference running in parallel. It is one day shorter and you can find the official coverage at http://www.utcoverage.com/German/20062.

Read on!

Welcome session – Rainer Becker

First, the attendee count comparison. As for years 2004 and 2005, the conference has had around 200 attendees. This year the count lowered by approximately 15% to around 170 attendees. Why is that so? Well, it is obvious that a new VFP version serves always as good reason to come or at least as a powerful reason to persuade one’s employer to send him to the conference. Since we are currently still in CTP, according to Rainer, this might have been the culprit of having a bit lower attendance.

Never the less, the future of the conference is inarguable. As Rainer stressed out, on every attendee’s conference bag there is a date list of all the dFPUG conferences in the past and future. It starts with the first one in 1994, through the one we have right now (the 13th), up to the 21st scheduled to come in 2014. With this at your disposal, you can always accurately plan your next visit to this great VFP festivity!

More than that, the 21st conference is sure to take place anyhow. It actually overlaps with Rainers 50th birthday and there is certainly no better place for him to celebrate it than among the community.

Best Practices Error Handling – Rick Schummer

Rick started his session by showing an inspirational design of his error handling dialogs and processes used in his real-world-not-demo-application called "Bug". Even though it might sound unbelievable, this is actually an application Rick developed and is used in a business specializing in "debugging" the real and alive "bugs".

The first part of the session focused on the error handling theory.

First of all, everybody in the audience agreed that errors just DO happen in our programs. We are just only pure human beings and making mistakes is part of us. Everyone also agreed that there should be a system to deal with them. All errors need to be handled, no matter if it is actually a mistake in the code or just an unpredictable set of events that occurred in the application and rendered something totally unexpected.

In VFP there are basically 5 methods to handle errors. The first one is to use no error handler at all by using an ON ERROR * command. Believe it or not, that is all you need to do to make your application bug free! No matter how comfortable this solution might be, it is usually not acceptable in serious applications. Neither is the second option, which is to use the default VFP error handler with the classical cancel, suspend, ignore and help buttons. Finally, the ones that might be successfully used in real world applications are global error handling with ON ERROR together with your custom error handling routine, the structured error handling using TRY…CATCH or utilizing the OnError event in objects.

Rick explained all the possible gains or pitfalls of each technique in depth, showed a couple of examples and talked about the usual combinations of all the techniques and briefly mentioned what common strategies are implemented by available some commercial frameworks.

So far, that was the first theoretical part of the session. The second part focused on different techniques helping to log errors, to communicate them to the developers, tracking them and so far. To sum it up shortly, the session shed light into the corners we sometimes as developers tend to overlook. The main goal of the session was to remind us, that we should not, if not for our users, then sure for ourselves.

Object Orientation – Michael Niethammer

In the beginning of the first session Michael explained the basic terminology, such as class, class library, instantiation, object and so on and clearly demonstrated everything on VFP visual classes. Later on he went on discussing and properly showing the inheritance, containership, properties, methods and finally events on easily understandable examples.

In the second session he focused on going to further details of already mentioned topics, such as methods and events in general or new topics just as access and assign methods. He also scratched the surface of many other areas, such as component designs, design patterns and explained many of the classical rules of thumb in object oriented development together with showing insightful examples.

Since the sessions were clearly intended for developers still spending most of their time in the structural programming, Michael spent considerable time explaining all the pros of the object orientation, but also its cons, just as that its adoption has quite a steep learning curve. Once mastered, however, it can only bring benefits.

More than just your typical office automation - Marcia Akins

Marcia didn’t start with talking about automation servers, but she showed us a marvelous video made by a friend of her which created a great atmosphere throughout the whole session.

If you were afraid that it would be too hard, you would be absolutely wrong because Marcia knew that not all of us were professionals. She started with basics of automation. First of all we must create a new instance (CREATEOBJECT (“Word.application”)). Marcia pointed out two things. First after creating a new instance we must make our object visible, because the object is created invisible by default and second much more important thing is that better than creating new and new instances which will slow down your application it is better to reuse existing instance using command GETOBJECT ().

Marcia showed us how to use Object browser to examine the properties and methods of automation sever. She told us that the object browser is our friend, and it really is. Object browser showed us the location of a help file and helped us to use Outlook methods very simply. Drag and dropping from object browser to your program window will cause the #DEFINE statement to be generated.

The greatest thing is that if you create new instance Visual FoxPro will be able to use IntelliSense and you can get result immediately such as changing the title of Excel graph, font or size. IntelliSense gives you an easy way to learn more about automation server. Then Marcia mentioned something about Event Binding and so on.

The session was absolutely great, full of many useful things and examples which Marcia explained into the every single detail. We are now all looking forward for the next part of “More than Office Automation”.

More than just your typical office automation - Marcia Akins

Hello everybody, it didn’t take a long time and we are back with the second part of Marcia’s session More Than Just Typical Office Automation. As we hoped Marcia begun with a funny story which was neither first nor last.

Second session started with another Microsoft program which was Map Point. Marcia showed us how to make a map point automation sever. At first you must create an instance using CREATEOBJECT () and then you can use methods such as FindAddress () or FindPlaceResult (). Marcia explained the difference between Route (consisting of WayPoints), WayPoint (consisting of PushPins) and PushPin (has own location). We have also learned how to optimize a route (you must have at least four waypoints) or a calculation of a route.

After we successfully passed Map Point we moved to Visio. It is a great way how to effectively generate work flow diagrams. The process of creating an automation server is the same as before except of that the instance of Visio will be visible right away. Creating a new document in Visio is different and the developer must use oVisio.Documents.Add( [] ). This is the way how it works, she said.

Marcia told us that Visio was the first program which could be automated. She pointed out that working with this object model may be difficult.

At the end Marcia gave us a brief introduction to Outlook and how to send an e-mail using automation and she also put a big accent on the fact that the automation servers are slow!

The session was very interactive same as the first one. Full of breathtaking examples, which shows you how it really works and of course filled with Marcia’s humor and enthusiasm.

Debugging Essentials – Rick Schummer

We started with FoxPro for Dos because it is good for understanding the heritage of this tool and because it is still used by many developers all over the world.

Another point of this session was to give us some basics about the debugger. Rick started with command which we can use in debugger such as:

Rick didn’t forget to mention something about tools option dialog where you are able to change your foreground, background and fonts as well. Returning to factory setting is also no problem except of fonts which you can not change back. You can highlight a code in a trace window and then you can simply just drag and drop for example into the command window.

Hidden tips where another things which was Rick talking about. Some of these tips were for example using trace window where you can find particular thing in your running code, but he mentioned that it doesn’t tell you if he fail with finding. He also mentioned Watch Window or Locals Window which shows all memory variables in scope.

Breakpoints were another important feature of the debugger. Breakpoints are good for stopping running code on specific row and Rick showed us how to effectively use this powerful thing, but Breakpoints are not only ones. Coverage profiler is another high-performance tool which can give you important data about how fast is your application.

This session was the right thing for those whose are not using the debugger and want to know something about that. The session was full of tips, tricks and techniques which are useful for developing applications without error.

Best Practices Working with Data - Andy Kramek

Is it good to use DBF as a primary storage place? If you thought that there will be few arguments you are terribly wrong. Andy pointed out, as a favor, for example:

There are also some disadvantages:

Andy also pointed out that DBF format is not well secured. DBF is such a standart, that many other programs can read, open and even write into it.

Where we should use DBF? Andy advised us to use DBF on separate local nets, where we can without any problems control the database.

Naming conventions was another topic of the session, where we found out many interesting things for example using plural names for tables and columns, keep column names in 10 character long or using abbreviations consistently or not at all. Another tip was using specific suffixes such as _det (means detail table) or _typ (type definition table).

After couple of time DBF won’t be enough and you will need database (DBC). Andy very shortly told us some benefits of DBC such as using long table names or possibility of a local view which is usually very useful.

The session was full of other things we had been talking about such as updating tables using SQL Update, Locate or Seek. Andy didn’t forget to mention something about indexes, when we should use them and when not.

At the end Andy showed us some examples where he demonstrate how quick update could be with and without index. This session perfectly combined theory and practical life experience.

Advanced SQL Queries with VFP 9.0 - Andy Kramek

Everybody of us had sometimes used SQL language, but nobody of us can imagine the true power of this language. This session is directed to demonstrate you some advanced techniques involving SQL, which can be used in Visual FoxPro 9.0.

Andy started with working with cursors. Cursors are result of SQL queries. Andy pointed out that our cursor created as a result of SQL query is READ ONLY, but in a minute Andy showed us solution as using USE AGAINST command. There are also existing alternative outputs such as file, screen and printer as well.

Then we moved to Joins. Andy at first mentioned Inner Join known also as “natural”. This Join is considered as a default join type. After that he was speaking about outer left and outer right join and full outer join which is combination of previous two. Full Outer Join is consisting of three sub sets of data.

Another useful thing which Andy demonstrated us was UNION. This command can combine two result sets from two queries. We know two tapes of UNION:

Sub queries were a next topic of Andy’s session. He explained us that Sub query is query embedded in query and it is good for getting one or more values. There are existing four types of sub queries:

At the end of the session Andy showed us some examples of queries and sub queries as well. These who were self-confident in queries Andy prepared some extra examples. One example just for illustration:

Friday, November 10

by Jan Vít and Jan Král

Windows Communication Foundation - Craig Berntson

Now, as early as after 20 minutes, Craig finally got to the overview.

Windows Communication Foundation, aka WCF, is a new technology available in the .NET framework version 3.0, which was released earlier this week. It is built from experiences from the current communication protocols and techniques, such as MSMQ, Web Services or COM+. This new technology is targeted to replace all of these current ones.

As the world of communication was evolving from calling methods (structured programming – 1970’s) through the object calls (object orientation – 1980’s) and components (1990’s) we got to the next step, sending messages (the service orientation). It would be a mistake to think that the object orientation is considered obsolete now. It is just the means of communication that have evolved from the one we know when there are objects directly calling one another.

The web services could be viewed as a start of the service orientation techniques, but are still not ideal and definitely cannot solve all the problems at hand and usually have to be also combined with other technologies.

The usage of WCF is pretty straightforward and in some aspects even similar to what we know from Web Services. They need an interface, so called service contract, which defines the operations/methods available and of course the actual service that implements the interface.

The WCF is very scalable, though easy to understand and start with. Craig also pointed out, that as far as he knows, there has been some official promise made by Microsoft to allow for this technology to be used from inside Visual FoxPro. Until that will happen, the technology is out there and available for experiments with help of Visual Studio.

Windows Presentation Foundation - Craig Berntson

This session was a starting point into a new and exiting technology called Windows Presentation Foundation, aka WPF. Even though it was released just this week and therefore is a really new thing, Craig already had many examples built on the previous CTPs.

When talking about WPF, it is mostly XAML. This new XML-like language allows developers to design the entire presentation layers and share them across Windows or Web environments. Introduction of this technology seems to have made the Windows and Web forms obsolete.

If you like what you here so far, you might want to test it by yourself. The only things you need for that are Visual Studio 2005, the .NET Framework 3.0 and Windows Vista SDK. You can get all of these very easily on a special web page dedicated to the new technologies concerning .NET framework 3.0. It is at www.netfx3.com.

Another useful tool is Cider. It provides the means for creating your XAML code in the classical drag and drop way you know from Visual Studio. This tool is also available at the already mentioned website.

What might also be considered a cool feature for companies having a larger development team or outsourcing some parts of the software development is that by having your XAML and programming code files entirely separated you can have the application design done by professional designers, not by programmers. In contrast to programmers, designers usually do like to spend time on design. Believe it or not, the look of your UI is what actually sells your application for the first time.

Since the session is held on a Visual FoxPro conference, Craig also mentioned possible ways of using this cool new feature from inside Visual FoxPro. The means for that to work is through an ActiveX control place on a VFP form.

With help of Visual FoxPro Craig showed various graphically attractive examples, such as a clock looking like a Vista Gadget or a handy zoom tool. To everyone’s surprise the last example featured an ordinary listbox made through WPF. That was only to show: “Hey, it not just about the fancy things, you can do the ordinary stuff in XAML as well!”

Application Architecture for Multiple UIs - Beth Massi

The trouble with mobile devices is that they usually tend to travel with their owners to various kinds of places and their connectivity changes quite frequently. We could, of course, avoid creating special software for them, just by putting everything that is needed by our mobile users to a website. Such website could then be easily browsed by any device. This, unfortunately, is not enough in all cases. Sometimes, there is a need to have the data available also off-line and to synchronize it on every reasonable connection. This basically is what the session was all about.

What really makes the device capable of running our software is something called Compact Framework. It is a small version of the classical .NET framework, just about 28% of it. It has been cut down in a way that it takes up less space without sacrificing too many features.

First of all, we need to decide, what part of the application we want to provide access to. Probably the easiest way is to build a façade on top of an existing business objects in the middle tier and by that achieving a clear separation of the business side of the application from the presentation side. This way we are also somehow shielded from all kinds of possible changes Microsoft might make in its communication software (such as WCF) and adopting our system to another communication standard should also be just about a little change in the façade.

After deciding what communication standard to use, we need to define our format of messages, the contract. Among the most common ones might be XML for small amounts of data or binary format for large pictures, for example. The easiest way, however, is probably sending a serialized dataset as it is something we can work with across many different platforms, including Visual FoxPro.

To make the “occasionally connected scenario” work, we also need some kind of software to keep the data on the client machine, even if it is just a small cell phone. The solution to this problem is a simplified version of SQL server, the SQL mobile.

In her presentation, Beth not only showed many examples with the use of the device emulator inside Visual Studio 2005, but she also brought a smart phone with her, which was then available for everyone to play with it right after the session. Her presentation was easy to follow and was filled with up to date information from the world of smart devices.

Instaling Applications Using Inno Setup – Doug Hennig

Doug introduced the Inno Setup. This setup wizard has a lot of great features. One of them is that Inno Setup generates much smaller files then Windows Installer does. Installation and uninstallation is much faster then with Windows Installer and Doug’s favorite one – it is absolutely free.

After small introduction of Inno Setup, Doug told us what we are able to do with Inno Setup Wizard. If we want we can offer more languages to our customer (English is default language) in a Setup Wizard or we can also set a password for installation. Installing a shortcut on a desktop and an icon of wizard is absolutely no problem. Licenses are another feature which allows us to put your own license text into the installation. If you want to, you can install uninstaller with your application, which will safely uninstall your program.

Defining the place where the application will be installed is another thing you can easily set. You can let the customer to choose where it will be or you can determine where the application will be installed.

Doug pointed out that Inno Setup is scriptable without any bigger problems. So if you are skillful you can adapt Inno Setup to your own liking. Inno Setup Scripts are just text files which are very similar to the .INI files.

The session gave us a great solution for installing and distributing our software. It is easy, fast and free and didn’t forget to mention a link where it can be downloaded, together with other useful resources.

Metadata to the Maximum – Andy Kramek

One of the developer’s nightmares is when he founds out that he needs to change something in an application. The problem is: Can you imagine changing your application without changing your code and even more? Changing an application when it is running? Andy Kramek is a live proof of that it is possible, even though quite an artful way of changing an application.

At first Andy defined three types of data:

Metadata is a data which supports the system. It is not a part of an application. Andy put a big accent on that. Sometimes Metadata is known as the data about a data he said. Metadata can be divided into another three parts:

But there is still a question? Should we even bother with metadata? Andy tried to persuade us that it is worth using it. Throughout metadata you can change your application in run time. You are not changing the code but the data. That’s the main and most important feature.

The problem is that if you want to change a code you need to shutdown the application, because the code is read only while the application is running. Typical exercise of using metadata in the real world is in a hospital. There the applications can’t be stopped.

On one hand the metadata is a great tool for changing behavior of your application in run time, on the other hand it requires more sophisticated code design and it may be harder to maintain and document.

Session was, as usual, full of examples which explained the concrete process as well as of other useful tips and tricks.

Datenanbindung - Michael Niethammer

First of all Michael created a project using command CREATE PROJECT and there created a form. After that he told us some information about the Data Environment where later on we put tables. Speaker didn’t forget to mention some important events such as BeforeOpenTable and AfterCloseTables as well. For methods lovers Michael mentioned OpenTables () and CloseTables().

We continued with the CursorAdapter. We started with the CursorAdapter builder and he explained how it works. Michael pointed out that if we want to keep our data in the CursorAdapter updated we must check off AutoUpdate field in builder.

We left the CursorAdaptor and the Data Environment and started speaking about Databound controls. These controls use ControlSource property and work with tables stored in our already filled Data Environment. These controls are for example:

At the end of the session we were talking about Table – buffering (pessimistic or optimistic), replace, delete, append commands. The Data Session was another topic and Michael put a big accent on the fact that the Data Session has nothing in common with the Data Environment.

The session was suitable mostly for beginners who are trying to work with the Data Environment and with Databounds controls and thank to great examples was no problem to understand how the Data Environment, CursorAdapter and other works.

Visual FoxPro Tools und Assistenten - Michael Niethammer

Visual FoxPro Tools was another sessions on today’s schedule. Michael wanted to let us into the mystery of Visual FoxPro tools and he started with the project manager.

First of all we created a new project and then Michael described all the part of this tool. If you want to have encrypted project you must not forget to check off encrypted, he said. The Project manager also gives you other possibilities such as setting icon to your application, including files into your project beginning with programs, forms, classes and ending with databases or single tables.

After this we slowly moved to creating menus with the Menu Designer. For simplicity we created a standard menu and on this model he showed us every possible setting such as working with result box, option box and so on. He mentioned that working with a menu isn’t objective oriented and he told us that menu file has .MPR ending.

Michael didn’t disappointed us and spoke about our favorite debugger which allows you locating and fixing bugs in your applications, watching variables, using breakpoints and other many things. He pointed out Error handling which is very important for developers and I can even say necessary. The main Error handling processes are done by using ON ERROR command, Error event or TRY…CATCH…FINALLY.

Other, without doubts, useful tools is the Class Browser which is good for controlling and administering Visual FoxPro classes. The Object Browser is good tool as well. Mostly is used for exploring external Word or Outlook class libraries.

The session was full of other tools such as the Coverage-Profile or the Document wizard, but speaking about all these tools would last at least another two hours. The session gave us the necessary overview about tools used in Visual FoxPro.

Filter, Indices, Rushmore & Co - Jürgen Wondzinski Jürgen Wondzinski, or as he is known "worldwide" as "wOOdy" (as it is known from passwords, please take care of the capitalization), presented his session about "Understanding Visual FoxPro by knowing where it came from" to his audience.

wOOdy not only enjoyed his audience with a well organized story of the different Visual FoxPro element, as well entertaining was his easy going style. So he introduced himself as FOXIL (just speak it loud and slowly...), being a heavily involved in the domestication "the Fox" since the late 80-ies. (Wikipedia says: Domestication is a phenomenon whereby a wild biological organism is habituated to survive in the company of ... human beings.)

Starting with the history about the creation of Vulcan and it predecessor wOOdy outlined, that the initial intent was to create data acquisition and retrieval system to be used be aeronautical and space engineer, administrative staff and their management at California Institute of Technology's Jet Propulsion Laboratory in the 1970. This was something like a "red ribbon", which wOOdy used in various places to explain the specific behaviour of Visual FoxPro.

Next wOOdy explained the basic differences between xBase und SQL. The data acquisition and retrieval system of JPL eventually had become dBase II (history see Visual FoxPro's History), which sold nicely in the upcoming PC-markets, serving its original purpose in the then typical PC usage better than anything else: Data maintenance and retrieval by being record-oriented.

The roots of SQL go back to a paper on A Relational Model of Data for Large Shared Data Banks, published in 1970b by Dr. Edgar F. Codd, which eventually became the blueprint for IBM databank development. As IBM has been serving the larger organisations, IBM and others were concentrating on large scale RDBMS systems, SQL as it was eventually called, became the language of these RDBMS running on large machines. This then naturally is the cause, that SQL is oriented on moving larger or smaller chunks of data at once. The well known consequences are that in order to fully comprehend the SQL language you cannot avoid studying the set theory. Or as wOOdy put it more pictoral: In the worst case you can with an wrongly used xBase command delete a table, with an SQL command wrongly employed on a SQL Database you can delete the whole database.

Further: xBase commands always work on individual work areas, SQL commands use on a SQL Database will always yield a data set. Seen from their history, xBase commands are record and table oriented, SQL commands are set oriented.

wOOdy outlined this by the development of the numbers of work areas of xBase / Visual FoxPro. First there were just 2 works areas. As PC grew up, got more memory, more disk space and the like, the next was just 10 work areas called A to J, which is the reason, that it still strongly advisable not the use one letter names for tables. Then the next step came and the limit was proudly increased to 225. Now we are at 32767.

Still there is only one table per work area and all command in Visual FoxPro (even the VFP-internal SQL commands) will work only in the actually selected work area.

wOOdy then went into the depth of "good" and "bad" commands. The criteria to differentiate between those two were the implied scope of these commands. If not considered properly this may result in quite some surprises, as wOOdy demonstrated explicitly.

As wOOdy outlined, in order to et s good understanding of the collection of different types of indices (Regular / Candidate / Primary / Unique / binary) you have to know the history. As always: presence has a past and future has a presence. So if you want to know, why you are where are now, you should know, where you came from. And before considering you future, you should know where you are now.

wOOdy finally then explained the secrecy to the speed of data access, with which Visual FoxPro still excels today: the Rushmore technology. By cleverly using simple bit schemas, which kept in the memory, this miracle is achieved.

Key Note - Yair Alan Griver

Well, you should see the VFP Videos specially manu(ally)factured by Kevin Ragsdale. Well done! And you will have a chance to help to promote Visual FoxPro as well. Just open the site and read on!

And we have another slogan for Visual FoxPro: Besides "Fox Rocks!" we now have

       VFP Connects!

Yag then showed, what Visual FoxPro is "connecting" and how it does it:

VFP Connects! You to your data!

The report generator has been completely renewed in Visual FoxPro 9. But this has been not the final stage of the evolution of this vital item of Visual FoxPro. Enhancements of the reporting are on the way. The runtime now is also decorator and visitor. You can preprocess a report to remove things that shouldn't show up - for instance, you can swap in a report at load time, create links for HTML, but prevent printing of the content (if this combination seems to be advisable), the properties of the report can now be handled dynamically at runtime, objects of the report can be rotated and quite a few more things of this type are likely to come to "connect the user to his/her data".

VFP Connects! You to SQL Server!

Visual FoxPro has its own strong database system, but SQL servers are around and are doing a job. So many people like them and most likely they will stay forever. So the Visual FoxPro team made a wise decision according one of the most basic rules of the successful: "If you can't fight them (these SQLs), join them (well that should read: integrate them). So the SQL Upsizing Wizard got a major refresh. Now it is a great tool to conquer the (data) world. Yag presented a demo, which had many of these quite convincing features. And he clearly demonstrated, how "visual" (= optically recognizable) a Visual Wizard can be.

Ease of use is one of the major features. So the SQL Upsizing Wizard can be started with default settings. Re-running it allows optimizing and customizing as needed. And for the speed fans: There have been improvements in the speed when upsizing to Yukon! Doug Hennig tested one table of over 300,000 records that used to take 2 hours. Now the upsizing takes 11 minutes!

VFP Connects! Us to Each Other!

Yag, in his career with Microsoft, is active in two fields: He is successfully overseeing the phenomenal implementation of data tools into Visual Studio and also is working actively with the developer communities.

Then CodePlex comes onto the stage, which is Microsoft's community development web site. CodePlex is a community platform, which allows developers to create new projects on topics they are interested in, in order to share their ideas and questions with fellow developers around the world. CodePlex allows developers to join others who have already started their projects in CodePlex and use whatever they learned from CodePlex projects and provide feedback.

Under these premises Yag actively promotes VFPX and VFPY, which is kind of the Visual FoxPro section within CodePlex. It is a Visual FoxPro Community effort to create open source add-ons for Visual FoxPro 9.0. In the keynote, Yag showed some enhancements from VFPX. Within VFPX code, classes, and libraries made available to the Visual FoxPro community. Presently these Projects are actively in development

• ClassBrowserX
• Code Analyst
• ctl32 Statusbar
• GDIPlusX
• JustBehave
• New Property and Method Replacement
• OOP Menu Project

VFP Connects! You to Visual Studio and .NET!

The NET4COM library is a collection of COM classes that wrap a subset of the .NET Framework 2.0. The .NET Framework is a rich collection of namespaces and API that provides a comprehensive set of functionality that developers can use to build applications that run on the .NET platform. While Visual FoxPro does have a rich library of API, there are some features that either do not exist in the Visual FoxPro libraries or are harder to use than in the Framework. NET4COM brings together a small subset of the .NET Framework - a collection of commonly used API that brings to Visual FoxPro functionality that does not exist.

The MY library for Visual FoxPro is similar to NET4COM. MY is implemented natively for Visual FoxPro and, similar to NET4COM, exposes commonly used functionality in a hierarchy that is easy to discover and navigate. The Sedna CTP Setup will install the MY library and related files in the "MY" folder under the selected install destination.

MY was introduced with Visual Basic DotNet. The MY namespace is a native Visual FoxPro class library that contains similar wrappers for SYS() functions, Windows API and Windows Script Host properties and methods. It allows statements like:

       MY.Computer.FileSystem.SpecialFolder.MyDocuments

And provides an easy way to obtain information about various directories like my Temp Folder, Desktop folder and the like. MY returns folders and files as objects and allows you to manipulate them.

NET4COM and MY are included in the Microsoft Visual FoxPro Sedna - Microsoft Visual FoxPro Sedna - Community Technology Preview (CTP) October 2006

VFP Connects! Sometimes quite surprisingly!

And then there is Jeannine Johnson! Never heard about her? well, there has been the "Start Something Amazing Awards", a competition which recognizes the unique and creative ways people use Windows and other Microsoft products. Jeannine Johnson from Puyallup, Washington, USA, is the Grand Prize winner in the section Sports & Games.

Despite physical hardships stemming from being born just 1 pound 10 ounces, preventing Jeannine from participating in traditional sports, she has found her niche in drag racing, where her 4’11” frame (ca. 1,50 m)and love for speed have helped her excel and succeed.

Sheer determination has fuelled 15-year old Jeannine Johnson’s passion for drag racing, and helped propel her to great success within her sport ( Video); she is one of only four NHRA Junior Drag Racers to ever achieve a ‘perfect package’ during a race (a feat that requires impeccable speed and timing).

Jeannine relies on Windows-based technology to help monitor her car’s performance and keep it running flawlessly, using technology such as Crew Chief Pro software to ensure she’s on top of the latest conditions affecting her car. Jeannine connects her Windows-based PC to her car’s Data Acquisition System, which measures engine RPM, jack shaft speed, and motor temperature variances from start-to-finish during each race. The results of these measurements are then evaluated by the Crew Chief Pro software package.

Crew Chief Pro - by the way - is a software package written in Visual FoxPro by Don Higgins. It and other software created by Don Higgins are widely used in the race scenery in North America.

Jeannine relies on Windows-based technology off the track, too. Among other things, she’s used Microsoft Windows Movie Maker to create a film about her drag racing adventures, and uses Microsoft Office Word and Microsoft Office PowerPoint to help maintain a 3.8 GPA and retain her racing sponsorships.

"Without these Windows technologies, my capabilities would be limited, not only academically but also in my hobby and love of racing."

VFP Connects! Us to Each Other!

There are a great variety of Sites on the web, which connects the community members, like

• VFP DevCenter
• MSDN Forums
• Universal Thread
• Foxite
• German FoxPro Users Group
• Yag's Blog

Saturday, November 11

by Jan Vít and Jan Král

Designing with UML - Craig Berntson

As this session was meant as an introduction to UML, Craig started with a brief introduction to the basic diagram types, such as use case, sequence diagram, class diagram, component diagram and a package. He spent a bit more time on the class diagram as this is the one most seen and shortly explained how we can draw elements like an interface, class, inheritance, container relationship and alike.

We are likely to use UML in many situations. First and an obvious one is when you are in the process of designing a new application. Then you most probably first create a use case for your users to clearly understand what the application is going to do when completed. When the use case has been blessed by future users you go on and create the class and sequence diagrams. This, of course, is not the “only-right-way-to-go”. You can certainly keep augmenting the diagrams as you are coding it. The last diagrams, you are going to create are the component and package diagrams, which give you the bird-eye’s view of your application.

Another reasons for using UML might be when you have an already existing application and only want to change some part of it or you get your hands on a completely unknown application and want at least get an overview of how it works internally.

To be able to create UML, you need a tool for it. There are many on the market today, including Rational Rose, Visual UML, Visio or the support for UML inside the Visual Studio 2005. One of the great ones that Craig recently discovered is called Sparx Enterprise Architect and used it for all his examples. Unfortunately, there is no UML tool for Visual FoxPro available today. Some of them, however, have means for extensions. Making it available for VFP should then be just a bit of work away.

Getting the most out of Reporting - Lisa Slater Nicholls

We were encouraged not to think that report listeners are the best technology to use at all costs. Sometimes the old-fashioned methods might work just as well or even with a better performance, even though they are usually more difficult to code.

Coming with the service pack, the VFP 9 addresses a certain difficulties working with GDI+ handles and gives more control over how many pages and what their parts are to be processed by a set of new report listener properties:

The most important thing when creating a report is to get the right data for it. They can be either in the denormalized flat form or a relational form. The flat form is very easy to use for the reporting, but causes a lot of duplicate data to be transferred over the wire (in case of data coming for example from an SQL on the server). Since all data should nowadays be treated as coming in from external sources, the recommended solution here is to really use the relational data, even if that means more work to be done when programming.

Since placing the data handling directly into the report itself is considered a bad practice, a set of a special data classes should be invented. Then they should also be enhanced with certain capabilities to properly work as data sources for reports.

The session contained many other interesting tips and tricks, such as generating a correctly formatted html by running the report twice, to get the pages total first and then accommodate the size of the paper for the report to look like it fits on one page.

At the end, Lisa pointed to an interesting resource about the Unicode, utf-8 to be specific, which is sometimes important to know inside out and can directly represent all Unicode characters, except Klingon, sorry.

Best Practices for the Middle Tier – Craig Berntson

The most important thing about middle tier is that it sits “in the middle”. It assures that UI and data backend never talk to each other directly. This separation into tiers can be made logically (by software only) as well as also physically by having each tier running on a different computer.

Although this might have changed earlier this week, COM+ was always considered the best practice for creating the middle tier. It offers many out of the box benefits, such as a built in security, transaction support as well as benefits of easy installation and administration.

Before Craig got to the COM+ and his examples, which were the core of this session, he mentioned a few other best practices for creating the middle tier. First of all, it is usually best to have our component stateless to minimize the amount of memory used in a particular time. If, however, your application needs to keep states, try to put them somewhere else, such as the SQL server. Again, to minimize the connection time, try to use methods with more parameters, instead of setting multiple properties on your COM+ object.

Another important thing is to decide in what form we are going to send the data. The VFP cursors are out of the question, since only VFP understands them and they are very much memory based. Custom object approach sounds a lot better, but still takes too much overhead. The best way probably is to use XML or ADO recordsets, in the end again serialized into XML.

When implementing the middle tier in Visual FoxPro, make sure you are using the session class as a base class for your objects as it has its own data session and has been optimized specifically to be used in middle tiers. Making it ole public and building it as a multi-threaded dll is all that is remaining to have the VFP COM ready to be put into COM+.

In a very clear example Craig actually showed the whole process of creating a VFP com to be suitable for COM+ and showed how to use it from UI. He talked about many other related issues, such as transaction support, distributing the COM+ application to the server and client and also about making the classical COM nightmare, the debugging, a bit easier to do.

Until Windows Communication Foundation really starts to kick in, COM+ is still THE way to built middle tiers so that apart from Visual Basic, Office or .NET even the Non-Microsoft clients can easily talk to it.

Adding IntelliSense to Your Applications – Doug Hennig

The IntelliSense is definitely the greatest feature put into the Visual FoxPro ever. It increases our productivity and it makes developing application much easier. Doug knew that and decided to tell us something about adding the IntelliSense into your own application, but there is a question. Is it necessary to add the IntelliSense into an application? Will user use it anytime?

The IntelliSense first appeared in Visual FoxPro 7.0 and it was the thing that every developer appreciated. Now in Visual FoxPro 9.0 we have a chance to include our own the IntelliSense into distributed application.

Doug continued with setting up the IntelliSense for run time. At first he tried to explain us how the IntelliSense works. The IntelliSense works by running program specified in the _CODESENSE. This system variable points to the FoxCode.app and so on. In our runtime the IntelliSense works in two places in a code window and in a memo field.

Everywhere is problem and so here is as well. Doug meant displaying all members of a class except these he wanted to use.

At the end of the session Doug was speaking about the FFI, registering classes with the FFI or using the Favorite for the IntelliSense Registration Editor where you can edit a namespace, description or choose methods and properties as well.

This session gave you a complete instructions how to include the IntelliSense into your application. It was definitely breathtaking flow of tips and tricks which make your application much friendlier for users. As would Doug says: “Users will love you for it”.

Extending the Data Explorer – Rick Schummer

Wouldn’t be nice to have a tool which will show us components in Visual FoxPro, SQL Server databases or other database using ADO connection? We don’t have to hesitate with answer. Yes it would. Rick Schummer showed us basics of the Data Explorer and not only basics. He even demonstrated us how to extend the Data Explorer.

Data Explorer is very similar to the SQL Server Enterprise Manager and Query Analyzer as well, but it has one big benefit. The Data Explorer is able to access the data in very fast way and it works will all data. Basically the Data Explorer explores your computer and network for components and databases. Rick pointed out that if developer has a big network, which is slow the Data Explorer starts slowly than on faster network.

Probably the greatest feature, what Rick mentioned, of the Data Explorer is simplicity. If you want to see a table structure in SQL Server, you have to click eight times to get it. In the Data Explorer tree click are enough. So the Data Explorer save your time, mouse and in other point of view it prevents of canal syndrome.

The Data Explorer allows you to build queries very quickly and what is the best is that you can add your own functions. Nothing is perfect. Rick show us how to us drag and drop function. He dragged a table from the Data Explorer and dropped to a form. You would expect a grid occurs. It did but without data. He repeated the process with column of a table and it worked perfectly.

After Data Explorer tour Rick moved to extensibility of the Data Explorer. For example the Document Database functionality or the Add-in Manager, this allows you to extense your Data Explorer.

At the end of the session Rick told us something about new features in Sedna and then he summarized the session and of course he gave us an advice: “The key is right click everywhere where it is possible”.

The Power of Cursor Adapters – Venelina Jordanova

The CursorAdapater is the first Visual FoxPro class allows us to connect with our application to other data source simply just changing the connection in run time. Venelina pointed out that using the CursorAdapter is the path of developing application using more data source such as data on SQL Server or Oracle.

After that Venelina easily describe how the CursorAdapter is working, how he is connecting to native, ADO or ODBC data source and converting into a Visual FoxPro Cursor. Then changing data in Cursor and updating back to the server where we get it.

The range of the CursorAdapter’s events is wide. Venelina mentioned couples of them which are important. For example:

Another topic of the session was data access setting. For this you can use the CursorAdapter Builder which is very useful, because it helps you to set all these things very quickly and easy as well.

Venelina wanted to mention something about updating data. When you are working the CursorAdapter class you can use buffering. Of course you can choose between optimistic and pessimistic buffer override mode. To write edited data we should use TableUpdate () function.

At the end of the session Venelina was talking about managing conflicts. For example what happen when the data is editing by more than one user. The ConflictCheckType property specifies how the object performs conflict checks during an update or deletes operation.

The session showed us complex solution of using more data sources in your application in run time. Everything Venelina demonstrated on simple examples and finally she showed us video and say goodbye with words: “Don’t give up and hang on”.

Best practices for class design – Marcia Akins

The time is not merciful and we have here the last day of our conference, but even we have the last day it still can be great. We decided to visit last Marcia’s session and we didn’t regret. Marcia’s topic was Best practices for class design and as usual Marcia started with funny video and this time she even prepared a lot of sweet prices for developer.

There is a question. When we should create classes? The answer is simple. Marcia told us that we have to create classes only when it is re-usable. It means that the code we can use more than once. For example class representing calendar. Another reason, maybe the main one, is “justify the effort”. Created classes should have their purpose. If you don’t have reason for creating class don’t do it, it is wasting of your time. For example she mentioned developers who have classes for everything even just for fonts. She called this designer class disease.

Marcia continued what we really must have in a class and what is needless. She divided into tree points:

Next Marcia was speaking about managing hierarchies. We have got two hierarchies:

She also mentioned Basic rules of Thumbs for example writing code in Methods not in events and so on.

The session gave us a lot of tips how to effectively design classes and how to work with them. Marcia didn’t let us to bore and she kept us concentrated all the time and if you were smart you could win a candy. Later, approaching to the end, session looked like feeding hungry developer with candy and sharing live developer stories. I must admin, and developers as well, that Marcia’s throwing skill is admirable.

Best practices for remote data access – Andy Kramek

First of all Andy explained us what the remote data is. The Remote data is data separated from application. That means storing data on the SQL Server or Oracle possibly MySQL. There are always some for and against:

We have place with data, we have our application and only what is missing is connection. Andy described us basic of connection to a database. We have two basic options:

Both these are different in implementation and in intent. The ODBC is good for only for relational data and using VFP the ODBC returns us a VFP cursor. What Andy pointed out was that the ODBC is perfectly supported by Visual FoxPro native functions. Using the OLEDB there is no direct support for Visual FoxPro.

Now here is question? What is better? Andy mentioned some of the myths, such as that the OLE DB is faster than the ODBC or ODBC is dead. Well there is no right answer, Andy said, but there is one thing obvious. Visual FoxPro is designed to work with the ODBC.

After all Andy started speaking about remote data tools. He mentioned tools such as the CursorAdapter, The Remote View (usable only with ODBC) or SQL Pass-Through (SPT). Remote Views are good for quick and easy access to the data. The CursorAdapter is much more flexible than the Remote View and it is possible to implement it over existing code. The SQL Pass-through has a good ad-hoc capability.

At the end Andy was talking about other things for instance the Command Execution, interacting with a Remote Data, the Transaction Management and at last the Stored Procedures.

The session didn’t miss speaker’s good mood and it was full of tips and tricks how to connect to a remote data without any bigger problems. Andy was also using a lot of examples that made his session interesting and informative as well.

Famous last words and raffle session – Rainer Becker

Probably the most important piece of information was that the next year DevCon date has already been scheduled. If you have read the report from the welcome session above, you also know that the date has already been set for another 7 conferences following the next one, just to help you make some plans for the years to come. Among the topics you can expect next year are:

Meanwhile, continue your programming, keep finding more unusual and extra cool ways how to solve your daily development problems and most importantly come again next year! We will see whether the Sedna release is really that far as her sister Sedna, the last planet of our solar system.

See you there (on the conference, not the planet)!

After the closing session, the official end of this years’ conference, everybody took the last snack with them and went home.

Final words and acknowledgements

We, the reporters, would now like to express our gratitude especially to:

Our extended gratitude goes also to everyone else who provided us with a never-ending support and helped us to fully concentrate on the reporting to be delivered as soon as possible to you, our readers.

Feel free to share your experiences from the conference, any notes on the reporting as well as your ideas of the UT coverage improvements on the UT forum. We are always happy to get the feedback from you!

Till the next time!

Jan Vít, Vitsoft   Jan Vít is a student of the University Of Economics in Prague. Since 1993 he has been actively interested in programming as well as other areas of information technology. His computer experience started with PC 80386 with FoxPro 1.02, later followed by higher versions for the DOS platform and since 1999 he has been using the newest Visual FoxPro versions together with other programming languages and tools. Presently he spends most of his time with Visual FoxPro 9.0, MS SQL Server and C# in WinForms as well as WebForms development. He has been a regular speaker on the Czech Visual FoxPro DevCons since 2004 and is also the co-author of many DevCon conference reports from Prague and Germany. His work now mainly consists of developing software for pharmacies.

Jan Kral My name is Jan Kral and I am studying Third Faculty of Medicine, Charles University in Prague. I am interested in computer technology and medical science. In my free time I develop applications using Visual FoxPro 7,8 and nowadays I use VFP 9.0, all mostly for my personal use. I have been a co-author of several Czech VFP DevCons' UT reports. I also develop internet web pages using PHP, JavaScript, CSS and so on. Feel free contact me at my email.