Day Zero

by Hans-Otto Lochmann and Armin Neudert

Hello again! We are now in Frankfurt, Germany, waiting for the German FoxPro DevCon to start. Like in the past we will start our reporting with a very short reference to the place, where we are now, the City of Frankfurt, where this event will take place.

The City of Frankfurt

Frankfurt am Main, located in the valley of the river Main, between mountainous areas of Spessart and Taunus, is nowadays one of the most important financial and commercial centers in Europe.

The origins of Frankfurt go way back into the past. In early medieval ages (794 A.D.) there is a first documentary mention of Frankfurt. Yet the place must have been inhabited much longer. Its name consists of two parts: "Furt" means river crossing and "Frank" comes from "Franken", which was the name of a closely related group of Teutonic tribes living along the Rhine valley, along the Main valley and further to the west. In the early medieval ages (500 - 800 A.D.) the Franks formed the most powerful empire in central Europe. Nowadays there is a region, called Franken, which is the northeastern part of Bavaria; well, the empire of the Franken still exists: The Germans call it Frankreich, English speaking people simply call it France.

Being in the cross section of all of this, Frankfurt became a place of trade and commerce. You will probably remember, that in the 4th century A.D. Sunday became the holy day of the Christians: What to do after the divine service in Church, which usually is on Sunday morning? Well, if you have enough traders in the city... So in Frankfurt these guys started to make some trades after the divine service, which - everybody was Catholic at that time - was called "mass". So they called these trade gatherings also "mass". This second meaning of the word "mass" survived in the German language until today: trade shows or fairs are still called "Messe", the German name for mass. By the way: the first time that fairs in Frankfurt were mentioned, is in old Jewish sources in 1150.

From the medieval time until today Frankfurt remained to be a world trade place. The picture to the right shows the Frankfurt Stock Exchange. There are quite a few international fairs, the probably best known internationally are the book fair and the IAA, the Internationale Automobil Ausstellung (international motor car trade show). These and other fairs lure annually approx. 2,5 million visitors and 37,000 exhibitors from all over the world to come into the city.

Mainhattan

What would trade be without banks? In Frankfurt there are now about 460 banks (130 from outside of Germany) and the fourth largest stock exchange in the world. These institutions are controlling quite a substantial portion of monetary funds in Europe. So when the EURO was introduced in 1998, the European central bank was located in Frankfurt. With so many banks, Frankfurt has nearly as many persons employed (569,000 jobs) such as inhabitants (650,000). Which in essence means that there is a lot of traffic around Frankfurt every morning and evening. The local Frankfurt airport is one of the busiest traffic hubs in Europe: planes are starting every two minutes each day.

Banks and trade fairs need houses. And as bank people are shy and tend to stick together, they build their houses closely together which in turn means they build skyscrapers. The skyline from Frankfurt is nowadays rather unique in Europe. Presently around 80 large bank and office buildings tower above the center of the city. Among the highest are the Commerzbank tower (258 m) and the Trianon of the Deutsche Bank (German Bank) with its two towers, called "Soll und Haben" (debit and credit). In many buildings visitor platform are open to the public, and offer unforgettable views over the city.

In addition, other industries have their location in this region as well. There are more than 2,500 High Tech companies located in and around Frankfurt, production and selling goods and services. 65 of the 500 largest European corporations (measured in turnover) are located in the area around Frankfurt am Main (Frankfurt on the river Main).

And someone couldn't resist the temptation and called that place "Mainhattan" - of course with a big smile.

Johann Wolfgang von Goethe

You cannot talk about Frankfurt without mentioning one of its "greatest sons" Johann Wolfgang von Goethe. He was born in 1749. He began studying law in Leipzig in 1768, which he had to interrupt because of a serious illness. He continued his studies of law in Strasbourg and finished in 1771. On invitation of Duke Carl August he moved to Weimar, where he started working as a member of the local government in 1776 until he died in 1832. As usual with public servants his daily workload could not have been very high, if you look on what he did besides that:

• a successful poet, whose works are still read worldwide today; he was using, as a scientist found out, the by far largest vocabulary of German words of any of the German poets before or after him (except for modern tech talk),
• a successful bon vivant and womanizer with lots of true and invented adventures, told by him or others,
• a successful operator of the local theater, which eventually became famous throughout Germany,
• a successful scientist, whose theory of colors strongly influenced the "3-item" structure of today (e.g. RGB) and whose collection and analysis of minerals strongly initiated a long living movement in the upper middle class to have collections of minerals at home.

Now two cities are preserving his fame: Frankfurt and Weimar. Both named places and streets after him. In Frankfurt even the university was named after him. Goethe's birth house was destroyed in the Second World War, but it was carefully rebuilt thereafter so it is more original than it was ever before. It is open to the public, of course with an admission fee (so you can express your admiration toward that genius of mind).

ISYS GmbH and dFPUG

Track: An introduction to Visual FoxPro (Part 1/2)

Today, this track started with three sessions and was presented by Michael Niethammer, managing director and co-owner of TMN Systemberatung GmbH, located in Ilsfeld (near Heilbronn - in the southern part of Germany). This track is a version independent workshop for developers that are new to Visual FoxPro or are not very experienced with VFP, yet. Until two years ago, there was a pre-conference teaching this content, but then Rainer decided to include these sessions into the main conference. The idea was to give attendees the chance to visit only those of the sessions they want to see and not forcing them to visit the whole workshop, even if they would only want to see the more advanced parts of it. Amazingly, this track had some of the most visited sessions last year, which in my opinion shows, that there are (or at least were) still many developers out there who are switching from older FoxPro versions or from other development tools to Visual FoxPro. The whole track consists of eight sessions in total and is spread over the first two days of the conference.

The first session (Introduction to Visual FoxPro) had the goal to give an overview over the possibilities and tools Visual FoxPro offers to developers. Michael explained the whole IDE including developer tools like the Object Browser, Class Browser, Profiler, etc. He also explained what Intellisense is all about and showed the most important Wizards. After that, he gave a quick overview of the Visual FoxPro base classes.

The second session is called "The Visual FoxPro Database Engine I". Michael covered all the important topics like how to create tables, including an explanation of field types and the different index types that are available. Then he explained everything you need to know about Database Containers, Stored Procedures and Referential Integrity.

Based on the knowledge taught in the second session, more advanced data related topics were covered in the following session called "The Visual FoxPro Database engine II". Working with Local, Remote and Offline Views as well as dealing with database events were the main topics. Michael also gave an introduction on the SQL commands built into VFP and SQL Pass Through.

To be continued on Wednesday...

True Windows Server Services with VFP

Now we get to the session of my fellow reporter Armin Neudert. He first explained what services are, what they are good for and then gave an overview of the whole service technology built into Windows NT, Windows 2000, XP (Home and Professional) and newer versions. He pointed out, that Windows 95, 98 and ME only support a very small amount of the things he was going to explain.

Armin then told us why a Visual FoxPro application cannot be run as a service without the help of other tools. Then he explained why tools like srvany.exe, Firedeamon or other wrapper applications are not the best solutions to run a VFP application as a Windows Service: They are not supporting all events a Service can support and they are especially having problems when it comes to stopping the wrapped application.

After that, he presented a solution that uses Visual Basic 6.0 and a free ActiveX control to build a much better wrapper application that talks to a VFP COM DLL. This solution supports all events like start, stop, pause, continue and Windows shutdown. The VB6 application includes a Timer object that periodically calls a method of the COM server, so the VFP application can do its job. The Timer object is situated in the wrapper exe, since VFP doesn’t support Timers in inprocess servers. Armin also showed us that the VB application asks the COM server for a message to put into the Windows Event Log after the VFP code has executed when the Timer had fired.

After an overview about topics like how to control a service application, what to know about communication with users and error handling in a Service application, he explained what is needed to know about the installation of a Service and demonstrated how easy the setup of his solution is. He built a new COM DLL and simply copied the wrapper application to another directory and renamed it. After that, the name of the COM class the VB6 part is creating was changed in the wrapper’s INI file, where you can also configure the timer interval. He executed the wrapper exe with a command line switch (-install) to get it registered as a Service. Then he switched to the Management Console and started the service, which was immediately running as expected.

Happy that everything went well and the audience appreciated his session, Armin returned to his job as a UT reporter ...

Software Architecture and Design Patterns

Nathalie Mengel introduced Design Patterns and the principles of software architecture to the audience. As Nathalie outlined, intuitively developed application designs may be successful now and then, but a well-structured design, derived from the proper use of Design Patterns, may be harder to get but will be superior on the long run. But knowing (and successfully using) Design Patterns is only one half of the story. Avoiding "anti-Patterns" is the other half. Knowing anti-Patterns is therefore essen-tial for a developer or a system designer to be successful. Therefore Nathalie presents both in her session.

Nathalie showed that software systems will have an ever enlarging influence in our daily life. If one analyzes the structure of today's spending on software, the majority of money is spent for maintenance and not for development. The main determining factor for the maintenance cost is the design of the software. Well-designed (and documented) software is maintained at a fraction of the costs, which will incur, if the design is hazardously sloppy. Sloppy designs usually result from a lack of understanding of the problem to be solved, careless analysis of outside influences, lack on determining all of the parameters and so on. When these fundamentals are not carefully laid, then even the best design wouldn't help. But usually carelessly setting up a project is accompanied by lack of understanding how to design a system in a good mannor. So there is virtually nothing, which will prevent the usual disasters from happening. Contemporary example in Germany: the embarrassing delays in the introduction of a truck toll collection system.

Though it is not a universal remedy, carefully and thoroughly structuring the software system is essential to avoid most of these problems. Structuring the software thoroughly and carefully is called Software Architecture. Software Architecture partitions a system into separate units - components and subsystems - with defined responsibilities and interactions.

Well-designed software components are self-contained. Each component is able to perform certain tasks or duties, for which it is designed. It also has a well-defined interface through which it communicates with other components. The combination of these components and their interactions form the application system.

As Nathalie pointed out, these components are called objects. These objects are created at runtime from a basic design, which is patterned or derivated thereof. The functionality of these components is determined by these designs. The design also determines the interaction of these components among each other or with the environment.

The more independent these components are from each other, the less changing a component will influence its relationship to other components or influence the relationship of other components among each other. The greater this independence can be made by an appropriate design, the more stable software architecture will be.

Stability is one of the non-functional characteristics of software, which should not be neglected at any price. Nathalie explained that functional characteristics are placed in the center of everybody's attention, because the "specs" often only describe, what kind of functionality the user expects. Non-functional characteristics are usually omitted in the specifications, but are, as Nathalie outlined, essential for the success and usefulness of the software. Besides stability, other non-functional characteristics include maintainability, expandability, reusability, and "testability".

In order to develop an application system efficiently, its architecture must be designed from the outset to take care of these non-functional characteristics. Once the software system is employed further non-functional characteristics like reliability or efficiency gain importance.

Nathalie then carefully explained the basic techniques of Software Architecture like

• Abstraction
• Packaging
• Information Hiding
• Modularity
• Separation of the interests
• Coupling and coherence
• Suitability, completeness and simplicity
• Separation from strategy and implementation
• Separation from interface and implementation
• Principle "single POINT OF reference"
• Principle "divide and more conquer"

Nathalie then went on to explain what Patterns are and what role they take in the software architecture. Patterns go much further than the principles explained above. They not only provide assistance or guidance, they also provide solutions, which can immediately be used.

While the above principles are derived by abstraction, the Patterns, which are used in today's software architecture are derived from analyzing the daily practice. Patterns do not only provide a solution for a given task and how they are employed. Patterns also describe, whether there are competing Patterns, which offer solutions to similar tasks and what kind of environmental influences have to be taken care of when a Pattern in question is to be employed.

Another important advantage of Patterns is that they do not only provide a solution, they also provide a complete set of rules how to analyze the system on hand in order to employ them. Complex circumstances can be understood much easier, if you do not have to find a separate method or solution for each given task. Patterns come with predefined characteristics and provide all necessary information on their employment. They provide - so to speak - a predefined set of modules with known characteristics, which can be easily combined to provide a solution. Discussions between developers are substantially simplified, because everyone knows and accepts, what a given Pattern stands for.

To make this better understood, Nathalie explained the nature of two well-known Patterns. She also explained why Layers cannot be considered a Pattern.

Knowing only Patterns won't help on the long run. Thinking in Patterns requires a strict discipline from every developer and from each member of the team. Therefore the "Anti-Patterns" were developed.

Remark from the reporter: While Antimatter is the opposite of Matter, Anti-Patterns are not the opposite of Patterns. Anti-Patterns are Patterns, which are the ugly brethren of well-designed Patterns.

As Nathalie outlined Anti-Patterns come into being because a sloppy solution was derived for a given situation or because a basically good solution was poorly employed. In order to avoid the pitfalls of Anti-Patterns they have to be known. But also it is worthwhile to know what the behavioural structures are, which will finally lead to these Anti-Patterns. Therefore Nathalie spent considerable time to outline the typical behavioral structures which lead to Anti-Patterns. Among these basic evils of software development are

• Haste
• Apathy
• Narrow mindedness
• Sloth
• Avarice
• Ignorance
• Pride

Using Copy&Paste programming as an example, Nathalie told us that even a good developer can fall into the pitfalls of Anti-Patterns if he/she forgets about the mental discipline any developer has to employ if he/she wants to be successful on the long run.

Business Objects - a strategy for the future

During his introduction on the methodology of Business Objects, Marcus Alt explained why they are something a developer should want to use. One of the most important points he mentioned was that Business Objects are the solution for the "Where is the code?" problem. We always know where the code for a certain task is or where it should go. That means easier maintenance, planning, reusability, which means you have a much better and clearer design due to normalization of the application logic. Marcus pointed out, that testing also becomes a lot easier, since you always have to do changes only in one place and not in several, so we can test small encapsulated pieces of the application regarding data access.

Marcus pointed out, that one should be aware that the number of Business and Process Objects may rapidly increase while working on a larger project. He said that we should not consider this a disadvantage. We will have a lot of classes, but we will always know which one to use and where to do our changes.

Using a detailed and extensive sample implementation, TMN (the company of which Marcus is a co-owner) uses for training classes on Multi-Tier-Architecture with Visual FoxPro, he then demonstrated how Business Objects can be built with VFP and how a good design for the implementation of Business Rule Objects can look like. The sample implementation is included on the conference CD and surely is a good starting point for people, which are new to this topic and want to get a start in the right direction.

Creating Hierarchical XML with VFP

This was the first session, Venelina Jordanova ever held in English here in Frankfurt. She is a principal of a software company located in Varna in Bulgaria (Eastern Europe). The company does the programming work of some of the enhancements for the Visual Extend framework that is now owned and maintained by the German FoxPro User Group.

The main target of this session was to show, how we can deal with hierarchical XML, especially using one of the great new features in Visual FoxPro 8.0: the XMLAdapter class. Many of us have already been working with the XML functions that were introduced in Visual FoxPro 7.0, but the possibilities the XMLAdapter brings to us, are much better, as Venelina showed us.

She first made a short introduction on XML in general and then explained what makes a well formed and a valid XML document. Then Venelina explained the basic knowledge we need to know about the XMLAdapter itself and its member classes XMLTable and XMLField. She explained that the XML adapter is a two-way tool that not only gives us the ability to load hierarchical XML, but also offers functionality that lets us manipulate and save these kinds of documents.

Venelina showed us how to load an XML document into an XMLAdapter object and explained how we can access the content and how we can create VFP cursors out of the tables included in the XML with the ToCursor() method.

After that, we came to creating DiffGrams. A DiffGram is a special kind of an XML document that is designed to describe changes made to data. Venelina pointed out that we should take care to SET MULTLOCKS ON and enable table buffering in order to be able to create DiffGrams, regardless whether we are using the XMLUPDATEGRAM() function or the XMLAdapter for this task.

Then one of the most interesting parts of the session began: How to create hierarchical XML with VFP. Unfortunately, the XMLAdapter class doesn’t provide a possibility to accomplish this task. Venelina showed us a way to work around this limitation by putting child data that was created using a second XMLAdapter class, into a memo field of the parent cursor. It also needs some more trickery to have the child data XML formatted end encoded the way we need it, but in the end Venelina presented a valid and well formed hierarchical XML document created with the XMLAdapter and some custom code. To demonstrate that the XML is really valid, Venelina finally loaded the document from an ASP.NET page, which properly displayed all the data.

Track: Visual FoxPro and Linux

This track consists of 4 sessions presented on one day in one sequence. Originally the Linux portion of this track was to be presented by Whil Hentzen, the well-known publisher, book author and confer-ence speaker. Unfortunately some illness prevented him from joining this DevCon. Rainer got the bad news only on early Friday morning. It was definitely to late to find a replacement among the already invited speaker on such a short notice. So Rainer decided to take over these "three sessions in a row" by himself with "a little help from his friends".

He hired a coach for him for the weekend and prepared slides and sessions by himself - the originally planed slides and session material were still in USA. Rainer survived barely an endless disaster of C0000005's due to various wrong configuration settings... At the presentation Jochen Kirstätter helped massively with technical details regarding Linux whereas Rainer did the slides and the presentation. Gerold Lübben then presented the MySQL part - as originally planned.

The Design Goals for Whidbey

• Personalized productivity
• Pain point reduction
• Comprehensive tools
• Path to the future

And here is the list of the new features and enhancements we learned about today ...

1. Language Enhancements

YAG pointed out that Microsoft is going to satisfy the needs of the language communities with Whidbey and that, of course, Whidbey will provide continued support for cross-language inheritance, cross-language debugging and full access to the .NET Framework. He went on pointing out that interoperability between the different programming languages still does not mean that they are not indistinguishable. The languages are not intended to cover what each other language contains.

1.1 Visual Basic

• Operator overloading
• Unsigned data types
• XML code documentation

1.2 Visual C++

• POGO - Profile Guided Optimizations
• Managed Extensions
• MFC enhancements

1.3 Visual C#

• Iterators: They will provide an easier way to implement the enumerator design pattern.
• Anonymous methods

1.4 Visual J#

• Browser controls
• Java-language keywords
• Swing functionality

1.5 Any of the contained languages

• Generics
• Partial Types

2. Development Environment Core Features

YAG stressed that all core features of the Whidbey IDE are designed and developed with the definitive goal to support developers with a more simplified and powerful IDE. This does not only include the ease of use of all available tools, wizards and so on, this also includes strong links to the community, which can be used easily. YAG was sorry that he was not able to show us all of the new core features, since there are so many of them!

• Drop regions for easier docking.
  Most of you will know this problem: You are trying to dock one of the many windows inside the IDE at a certain place, but you need several tries until you get it there since it is not docking where you want it to be. Here the Drop Regions come to our help. They are small regions indicating where and how the window you are currently dragging can be dropped. Remark from an attendee: "We want this for VFP!"
• Community Web Services
  • Maintained on MSDN
  • Accessed via Visual Studio IDE
  • Web services include:
    • Starter Kits
    • Project Templates for new Code Snippets, new My Classes, new Refactoring and Product Updates
• Extensibility
  • New VB My classes. One major new element of VB.NET are "My Classes". They are supposed to assist developers in writing code for common scenarios. The "My classes" are an easy and direct way to use the most important classes of the .NET framework. In his sample project, YAG explained the concept like so: the MyClasses are like a speed dial in a phone, a direct and easy access to many parts of the .NET framework. It will be possible to write much less code without a performance loss.
  • New C# code refactoring
  • New Code snippets
  • Customized profiles (includes window layouts, color schemes, key bindings, etc.)
  • Debugger visualizations
  • Additional Starter Kits
• Documentation and Help.
  YAG spent a considerable amount of time to present a first look on the new Help file features, which will provide a much more intelligent and supportive information basis to the developer. Navigation in the help file is more task oriented and the search function has improved a lot. We will be able to set several search options. We have seen one, we will surely love: "priorize topics with code"! Further more, we will be able to make comments in the help file that can be saved! I am pretty sure you will like this feature. This way you can have all information in one place: the help texts, comments and information you have collected from other sources!

3. Development Environment - Building Apps

• Code Refactoring / Code-focused RAD / Disciplined code restructuring.
  Another important theme for Whidbey are Code Refactoring possibilities. The idea behind this is "code-focused RAD" and disciplined code restructuring. Alan showed an example, of what this means for the daily business of the developer: When we are recognizing that we need a piece of code anywhere else for a second time, we will be able to mark those lines and tell Whidbey to make a new method in any class out of it. The original code is replaced by a call to the new method. And note that the IDE is smart enough to find variable names in the code snippet and to use them as parameters in the new method. Of course, the method call will also contain the correct variable names in its argument list.
• My Classes for VB
  • Assists programmers in writing code for common scenarios
  • Customizable and extensible
  • Create additional "My" classes
• Auto-Correct and IntelliSense.
  The Auto-Correct feature will help you to find and correct code that is not correct. This works like a spell or grammar check in Word. IntelliSense will be enhanced by introducing filtering, so that only relevant and frequently-used class members are visible.
• Code Snippets.
  Templates for more complex common code tasks - like upgrading from Visual Basic 6 are provided.
• Code Formatting
  • Default options are .NET coding guidelines
  • Applied at file, project, solution level
  • Can be shared with team
• Windows Applications
  • Ease and safety of Web application deployment
  • Richer user experience
    • New controls
    • Simplified data access (e.g. Drag and Drop of database fields on forms)
    • The Immediate Window for Visual Basic (which is the counterpart of the Visual FoxPro Command Window) will always be available, not only while debugging.
    • A new "Getting Started" task pane
    • IDE Navigator: similar to ALT+TAB in Windows, but here meant to switch between open IDE windows in a fast way
  • Faster development
    • Fewer lines of code
    • Fewer clicks
    • A new project must not be saved before code can be run.
      This is nice for testing a small piece of code outside your application.
  • Improved performance
    YAG showed some encouraging examples.
• ASP.NET Web Applications
  • Faster development
    • Simplified data access
    • Reduce ASP.NET code by up to 70%.
      Here YAG showed us how easy it is to implement paging, sorting, etc. for grids.
  • Consistency and appearance
    • Master Pages
    • Themes and skins
  • Improved performance
  • Mobility built in
  • VS.NET comes with a new secure personal web server that can only be called from the local host and installs under a normal user account. So IIS is no longer needed on the machine you’re developing on.
• Device-based Applications
  • Target .NET Compact Framework 2.0
    • Smartphone, Win CE .NET 4.2, Pocket PC
    • Telephony
    • MSMQ
    • SMS
  • IDE support for native C++
    • Consistent experience
• Office Solutions
  • Schema-based Programming Model
  • Extended Office Controls
  • Assembly in document with signature or strong name
  • Server-side document creation
  • Smart Doc framework
• Data Access
  • Make the 80% data access case easy
  • Find and incorporate data tables much easier
  • Gain more control over data binding
  • Use SmartTags to help guide the programmer
• XML tools enhancements
  Due to a kind request from Ken Levy - "Ken will kill me, if I'm not showing you the XML tools" :)
  Alan showed examples of the XML Tools Ken is currently working on. We saw a very large XML file opening really fast in the editor and an Intellisense list that was only filled with elements that can be used at the cursor position. YAG then pointed out that lines in a stylesheet are compiled in the background while typing. This enables the IDE to immediately indicate whether the line is valid. He demonstrated that it is possible to change stylesheet code while previewing it.
  And here's the list of all the presented things:
  • Editing XML documents
    • Validation and IntelliSense from XSD or DTD
    • Custom XSD schema folder for XML validationLanguage
    • Editor style experience for XMLOutlining expand/collapse in XML editor
  • XSD schema inference
    • Create XSD schemas from XML or DTS files
  • Editing and debugging XSLT
    • XSLT language editing with IntelliSense
    • XSLT debugging with language integration!
• Yukon Integration (the next version of SQL Server)
  Whidbey will support the Yukon project system and we will be able to write Stored Procedures in managed code with the possibility to seamlessly step across T-SQL and managed code.
• MS Build
  • Whidbey and Longhorn build engine
  • Documented file format
  • XML-based
  • Scalable, extensible build platform
  • RAD support in Whidbey IDE
• Debugging
  • Simpler debugger interface
  • Debugger data tips
    This feature assists developers with tips about how he can solve a problem and possible actions to take.
  • Debugger Visualizations
  • View data stored in complex data types (Collections: Tooltips scrollable)
  • Supports built-in .NET Framework types
  • Extensible for user types
• Upgrade Strategy
  • Seamless upgrade from Visual Studio .NET 2002 and 2003
  • Visual Basic 6.0
    • Improved control migration
    • Support for control arrays
    • Keyword changes
    • App object
    • Form default instance
    • Forms collection

4. Enterprise

• Expanded VSIP
  • Deeper integration
  • Common services
• Visual Designers for Service Oriented Applications

As we have seen, Whidbey will be an exciting new release of Visual Studio .NET with a whole lot of new features and enhancements!

Track .NET: Business Objects With ADO.NET

Manfred Rätzmann first introduced himself. An interesting point in his biography is a book he wrote about software testing about a year ago.

While explaining what Business Objects are he mentioned that we should take care that they are designed in a way so they can be used under all common circumstances to ensure that we consider most of the scenarios we might face in the future:

• In a Fat Client application
• In a web application
• In a web service
• In batch processes

After giving a brief introduction on Business Objects in general (this session was a more advanced one), Manfred introduced a so called Business Object Manager class. It is responsible for every job that has to deal with multiple instances of the same Business Object. This way the Business Objects have a good level of encapsulation and are very lightweight. Then he gave an example for two common tasks so we all know whether a certain job should be done by a Business Object itself or by a manager class. A client business object could be able to give the sum of open accounts for one client, but it may not create a query result that tells you all the turnovers for all or some of the clients in your database. A Business Object Manager class can also create new instances of a Business Object or save changes of existing ones.

He then explained his Service Provider class, which is quite the same as a Business Process class, besides the fact, that Manfed’s class is only responsible for processes where different business objects are involved. When only instances of the same Business Object class are involved, the Business Object Manager would be the right place to code these kinds of things into.

We then saw the implementation of the model using the C# language. Manfred explained how he coded all the things he was teaching us in theory before. He showed us how flexible his approach is, by switching the data source for his demo from a Visual FoxPro database that was accessed using the VFP OLEDB provider to a SQL Server database which was directly accessed via the SQLServerAdapter.

Manfred mentioned during his session that he already created implementations of the presented model in Visual FoxPro, .NET and Delphi successfully. So we can see, it is universal as it should be, since it is "just" a model and has (nearly) nothing to do with its implementation that comes later. Of course, you always have to take some things of the programming tool you are doing the implementation with into account (e.g. strong typing), so the model really fits.

Track .NET: Architecting for the .NET Event Model

Like always Kevin McNeish’s session started with a funny part, instead of the actual topic. This time we were able to see a small video sequence of Rick Strahl laughing for over two minutes. I will leave it to your imagination to figure out what happened in the room during those two minutes :)

Afterwards Kevin started with an introduction to the .NET Event Model and pointed out that the design of it is based on the Subject-Observer Pattern we all know. We saw the regular code we need to bind controls to data in .NET. Then he explained the goal of getting this done in a Visual FoxPro way, what means that we only need to fill in a DataBind property instead of writing multiple lines of code.

In order to get this done he started with a clear and detailed explanation of all necessary steps for creating events in .NET:

• Creating the event
• Creating the Delegate
• Defining Parameter Objects
• Defining the method that fires the event
• Defining the eventhandler method
• Registering the handler with the event

Especially the way he explained this quite complicated concept of delegates helped attendees to get one of the major hard to understand parts of .NET programming into their minds.

After being through all steps Kevin pointed out what can be done with these events:

• Establish a relationship between Business Objects: Business Objects can send out events to inform the observers (listeners) when anything interesting happens in the object.
• End user configuration security: The ability to do the application security setup in running forms using custom events to tell every secure control to switch into security mode and back again. This is working in Windows- and WebForms applications!

And for sure, the session goal having intelligent data binding in Windows- and WebForms was achieved with the result of being able to simply set one property and the databinding is done.

We got a good demo on all of these topics and Kevin showed how he implemented all of this in Mere Mortals .NET.

Track .NET: Introduction to multithreading

Rick Strahl's session started with a detailed part, explaining what multithreading is and where you would want to use it. Besides obvious examples like server or monitoring applications he also pointed out things like keeping the user interface "responsive" and the ability to interrupt operations.

After that, Rick described some of the problems that exist and have to be solved when using multithreading. A closer look to the way multithreading works in .NET was the next step in his session. He showed us how easy it is to create and use threads and what different possibilities, e.g. multithreading with delegates exist.

Good real life examples like sending mail in the background without meanwhile blocking the user interface helped to understand the technique and the code you need to implement.

Many tips and good hints for solving problems in a multithreading environment followed this presentation and the session ended with a demo of a WebMonitor application and a few explanations about debugging in multithreading environments.

And who didn’t get everything the first time has the chance to re-read it in his 26 (!) pages of session notes included in the conference binder.

Workarounds: What to do when ...

• AllowCellSelection = .F. grid allows mouse-clicking into custom column control.
• Black HighlightForeColor is ignored.
• Cannot set Name for member class.
• Current row highlight ignored for Column.Sparse = .F.
• Enforce validation of data.
• Grid.When()=.F./Grid.Enabled=.F. ignored when grid.AllowCellSelection = .F.
• Leftward keyboard navigation from first column shifts columns.
• RETURNing .F. from Control.Valid() doesn’t prevent cell from losing focus.
• Rightward keyboard navigation shifts columns.
• .SCX-based forms won’t load when ControlSources set in Properties Sheet.

Design Patterns - practical use for the nice sounding theory

In this session Marcus Alt started off with a small introduction of Design Pattern history and explained what design patterns are and from where you can get further information. Afterwards he went through different examples of easy to code patterns and showed the idea behind them as well as the according code. He although gave ideas of where to use the patterns in real world applications.

Starting with a BINDEVENTS implementation of the subject-observer pattern, Marcus went through the following patterns:

• Strategy
• The Template pattern which can be used while coding the strategy
• The Abstract Factory that is used to instantiate Strategy objects
• The hook pattern

Many examples helped attendees to get a feeling of what design patterns are and for being interested to keep up with the topic in the future.

Track Microsoft SQL Server

And here’s another track, which was introduced last year. Speakers are Dan Jurden (four sessions in this track), Daniel LeClair (also four sessions) and Venelina Jordanova (one session). This year, the track consists of nine different sessions in total and covers several interesting topics like an introduction to SQL Distributed Management Objects, the Data Transformation Services (DTS), SQL Server’s XML features, User Defined Functions, DMO, the sessions covered below and several more. This track completely consists of English sessions. It’s always a pity that we cannot be in and write about every session, to cover all of the interesting topics.

Track SQL Server: Beyond SELECT: Advanced Queries for SQL Server

Daniel LeClair, an independent consultant, covered a whole lot of things we can do with SQL Server’s built in programming language T-SQL. He first explained the difference between the way data can be retrieved and manipulated in T-SQL. He pointed out that this works quite similar like we are used to with Visual FoxPro in some places, but that there is a main difference: In T-SQL you are mainly working with "sets" of data in contrast to VFP, where we are more used to access single rows of data. Daniel pointed out that he is mainly showing us things that are not only applicable to SQL Server 2000, but also to SQL Server 7, so that people still using the older version will have a benefit of his session, whereas some things are limited to MSSQL 2000.

Daniel explained and presented interesting things like the use of dynamic SQL statements, using system tables in queries, using temporary tables and cursors, and other T-SQL capabilities beyond just getting back a result set. Using Cursors, Dynamic SQL Statements, UDFs, the Table Variable Type, CASE statements, Derived tables were covered as well.

Track SQL Server: Extending T-SQL with COM

First, Dan Jurdan, working as a Senior Application Developer for EPS-Software Corp, explained that T-SQL (SQL Server’s built in programming language) has strong limitations when it comes to more complex tasks that are not directly related to data access. Many people have faced this problem (note from the reporter: you can count me to them, as well). However, it is possible to use COM objects, like we can create them with Visual FoxPro, in T-SQL to extend the functionality, Dan pointed out.

He went on, explaining all Stored Procedures that are provided by SQL Server in order to access COM servers and showing us, what the T-SQL code using these SPs looks like:

• sp_OACreate
• sp_OASetProperty
• sp_OAGetProperty
• sp_OAMethod
• sp_OADestroy
• sp_OAGetErrorInfo
• sp_OAStop

At the end of his session, Dan outlined that we should be careful using COM server calls e.g. on a high volume Web server, since using this technology can cause a considerable performance problem. On the other hand, he told us, using COM servers might come in quite handy, when using them on a server that is not that busy all the time, and not too many users are working with.

And another note from the reporter: YAG announced a great new possibility to extend T-SQL in a seamless way with the upcoming new versions of VS.NET and SQL Server. We will then be able to create Stored Procedures with any language included in VS.NET!

The Class of '94

Ever met the Class of '94? Never? Well, you should have attended this conference. Due to a carefully designed and well-coded application the team of the dFPUG was in the position to identify the Class of '94. Who are the members of this class? Rainer proudly presents "his" Class of '94, the persons who have been attending the German DevCon for 10 consecutive years in a row: They are:

• Norbert Abb
• Alfred Bechtel
• Alf Borrmann
• Martin Dubovy
• Sebastian Flucke
• Peter Krause
• Wilfried Laßat
• Hans-Otto Lochmann
• Elfrun Scheel
• Hanno Ritzerfeld
• Kai Rogler
• Eugen Wirsing
• Jürgen Wondzinski

Three of them (Jürgen Wondzinski, Sebastian Flucke, and Norbert Abb) have also been speakers in all of these DevCons and one of them (Eugen Wirsing) develop himself from a simple attendee into a well esteemed speaker.

The closing session

Well, this is the last session of this year's Frankfurt Conference. Rainer Becker told us that everything went so smoothly this year that he sometimes thought he was unemployed (big laughter in the audience!). Of course, he was busy enough, just not the whole day and longer - only the whole day. He thanked the audience for coming and told the usual stories about how he finally convinced the "chef de cuisine" of the hotel to offer Hamburgers during at least one break. You have to know that the food here is really amazing! You can see some photos of the buffet using the picture archive of this coverage.

As an outlook for next year’s conference, Rainer mentioned that we would have a new track about the "Report Writer". Please see our report of the Europa keynote, so you can see that we will get so many enhancements so that you really can do a whole track to cover all of them.

Then we got to the usual raffle. All people that filled in evaluation forms now can win a price. Like in every year before, Rainer gave away prices like a Visual MaxFrame Professional package sponsored by Vision Data Solutions handed over by Drew Speedie, a List&Label Report Writer package sponsored by ProLib, two signed Megafox Books and two packages of Visual Extend sponsored by the dFPUG itself and more.

Acknowledgements.

Ever wondered, why certain events like this DevCon happen so successfully? Well, this is one the reason: There is a jointly pushing team behind it. Here it is the team, which always strongly, knowingly and reliable supported Rainer Becker:

• Tina Flieher-Ojen,
• Andelko Sicenica,
• Michael Vogel,
• Sven Wilke

And of course there was ample support from the well tried, reliable, and experienced proof reader Brent Speedie (11), who helped to make the wording of this report to become "real English".