 |
| 
|
| 2008 |
|
|
|
| 2007 |
|
|
|
| 2006 |
|
|
|
| 2005 |
|
|
|
| 2004 |
|
|
|
| 2003 |
|
|
|
| 2008 |
|
|
|
| 2007 |
|
|
|
| 2006 |
|
|
|
| 2005 |
|
|
|
| 2004 |
|
|
|
| 2003 |
|
|
|
| 2008 |
|
|
|
| 2007 |
|
|
|
| 2006 |
|
|
|
| 2005 |
|
|
|
| 2004 |
|
|
|
| 2003 |
|
|
|
| 2002 |
|
|
|
| 2006 |
|
|
|
| 2005 |
|
|
|
| 2004 |
|
|
|
| 2008 |
|
|
|
| 2007 |
|
|
|
| 2006 |
|
|
|
| 2005 |
|
|
|
| 2004 |
|
|
|
| 2007 |
|
|
|
| 2006 |
|
|
|
| 2005 |
|
|
|
| 2004 |
|
|
|
| 2003 |
|
|
|
| 2004 |
|
|
|
| 2003 |
|
|
|
| 2002 |
|
|
|
| 2001 |
|
|
|
| 2000 |
|
|
|
| 1998 |
|
|
|
| 1997 |
|
|
|
| 1996 |
|
|
|
| 1993 |
|
|
|
| 2003 |
|
|
|
| 2002 |
|
|
|
| 2003 |
|
|
|
| 2001 |
|
|
|
| 2003 |
|
|
|
| 2002 |
|
|
|
| 2001 |
|
|
|
| 2003 |
|
|
|
| 2001 |
|
|
|
| Visual FoxPro 2001 |
|
|
|
| Visual FoxPro 2000 |
|
|
|
| Visual Studio 2000 |
|
|
|
| West Wind 2002 |
|
|
|
| Double Impact 2001 |
|
|
|
| FoxTeach 2001 |
|
|
|
| Jam sessions |
|
|
|
| Technical Guidelines |
|
|
|
| About |
|
|
|
| Acronyms |
|
|
|
| Contact information |
|
|
|
| Troubleshooting |
|
|
|
| Time zones |
|
|
|
| Web Service |
|
|
|
| Terms & Conditions |
|
|
|
| Copyright |
Our 2008 Conference begins on Thursday, November 13th, and finishes on Saturday, November 15th. The Saturday is a complete and unabridged, fully valid conference day! This year, three-day visitors can thus save one day of their regular working week. Last year more than a few participants asked us about a way to better reconcile one's usual weekly workload with attending the Developers Conference. The Thursday-to-Saturday scheme takes a step to fulfill this widespread wish. Apart from this, the attendees can take advantage of lower hotel prices.
| Date: | ||
| Location: |
Day Zero
by Jan Vít and Jan Král
Looking at this year’s conference schedule an old Latin saying comes to my mind: “tempus fugit”. Right at the top of the session schedule, there is a big heading that says: “15th VFP and 7th SQL-Server & .NET Conference”. 15th! Thinking of it now, the time really does fly.
Personally (Jan Vít), this year is my 5th time here at the conference and I already do feel like I have known this event forever. I know every room, every corridor and sometimes I even recognize the conference hotel personnel, the waiters, waitresses and others. I am just wondering and trying to imagine how the attendees that are here for the 15th year must feel. And guess what, there are such ones. Not one or two, but 10 or 20. Incredible!
Just as every year, the organizers prepared three rich conference days, filled up with sessions about Visual FoxPro, SQL-Server and .NET technologies. Right now, counting directly from the conference schedule, I see a total of 63 sessions, including the keynotes and vendor sessions. The majority of these are presented in German, but there is always at least one or two English ones running in parallel. Each and every session also has its session notes available in a sizeable conference binder and on a conference CD. For those, who like to stay awake a bit longer and get even more information after dinner, there are the late night sessions available. These, if I remember correctly, many times tend to continue long outside of the session rooms, in a wonderful mood, right in the bar with a fine glass of beer.
Compared to the last year, the attendee count seems to have dropped a bit. This, however, in no way impacts the size or the quality of the conference. There are many new speakers present as well as the usual and proven ones returning. For the first time at the German DevCon we can hear Bo Durban, Tamar Granor and Steffen Pirsig speaking. After a short pause, we also have Ken Levy, who will share some thoughts on converting VFP projects to .NET and Kevin McNeish, who will be speaking about .NET in general.
All in all, this year´s DevCon again seems to become a promising one. It brings an opportunity to get to know what is new in the Visual FoxPro, SQL and .NET worlds and provides a place to meet the people with similar interests and topics to discuss. We, the reporters are thrilled to be part of it again and will bring you both in text and picture the most interesting moments and details right here, at the Universal Thread Conference Coverage website. Stay tuned!
Thursday, November 13
by Jan Vít and Jan Král
KeyNote – Rainer Becker, Ken Levy
Prior to lunch, there has always been the right time for the traditional Keynote. This year Rainer Becker was assisted by Ken Levy.
First of all, Rainer took a few moments to talk about the recent activities around Visual FoxPro and the Visual FoxPro user group. Later Ken Levy took over to share some of his thoughts about Visual FoxPro and its recent path of development.
As he recalls, Ken started his career as a long-haired, always-in-shorts-dressed programmer since in 1981. Later on, he started using dBASE II, FoxBase+, and eventually got to FoxPro and became its devoted supporter and evangelist. He started contracting with Microsoft, supplied some ideas as well as some of the tools we know and use today. Eventually Ken joined Microsoft and became the Ken we have known for quite a few years.
A few months ago, he decided to go a different path. He left Microsoft and started his own company as an independent consultant. One of Ken’s clients is EPS and one of his projects is working on the VFPConversion portal. If you like to pursue Ken’s activities further, be sure to check out his website http://mashupx.com.
After this introduction, Ken continued to explore the obvious as well as the not-so-obvious reasons behind FoxPro’s recent development. He started with a FoxPro 1.0 marketing video from the Fox Software, which quite frankly looks a bit archaic today. I am mainly talking about those large monitors, 5.25” diskettes and other BIG stuff! A while after the video had been shot Fox Software was bought by Microsoft. They spent $173 million for the number one reason of this acquisition: To hire those 7 bright developers of FoxPro there to join Microsoft.
During the Visual FoxPro development, there has always been a serious doubt about its future. This was especially true around the version 6.0, when the VFP team itself was told the version 6.0 was to be the last version. Microsoft had different plans - .NET. Thanks to the VFP team and the VFP community efforts, the development eventually continued further, until it reached its final version 9. Some of the VFP team members have since left Microsoft, and some have been scattered to other development teams within Microsoft. There is actually no longer a VFP team at Microsoft, just a few people who work on part-time things like hotfixes when needed.
VFP 9.0 is now in its final version, its core is stabilized, and the extended support was proclaimed up to the year 2015. What is important to realize now is that as far as the support is concerned, the end support date is basically talking about the official phone support. This in fact is not a major issue, since the community can and in many cases already has taken over this part of the support.
It is also logical to expect the important compatibility hotfixes to keep appearing. The simple reasoning behind this is that if Microsoft wants to come up with a new platform, say the newly announced Windows 7, it has to make sure the existing applications will run on it. Otherwise no one would upgrade. Correct? When thinking of the future support of Visual FoxPro, it is vital to keep this platform compatibility issue in mind.
What is also expected is that VFP 9.0 will no longer be available to retailers in 2009 as a stand-alone product or upgrade. The only opportunity to get it will be through an MSDN subscription. If you are now wondering what your future investment strategy might be, consider Ken’s half humorous idea of buying and stocking up on a few copies of VFP 9.0 at home and waiting until the eBay selling price gets higher.
All in all, the further development of Visual FoxPro is now in hands of the FoxPro community including MVPs, independent vendors, VFPX, VFP Studio, Guineu project, .NET Extender, VFP Compiler, and others. More details on these will be in Ken’s twin late night sessions today as well as in other sessions at this conference.
Making the Most of the Toolbox – Tamar Granor
Since Tamar is a well known person we are glad to welcome her back to Frankfurt - after 10 years.
Tamar started with introducing herself to those who do not know her and after that she asked us a question. What is toolbox and what is it good for?
Toolbox is an absolutely wonderful tool which will definitely make your developer´s life much easier.
She gave us a brief example how to start toolbox. We can use command Do (_ToolBox) or we can click on the icon for it (a crossed hammer and wrench). When she started her ToolBox, at first sight we noticed a different font. Her toolbox is using different font because the default one is smaller.
After that she continued with: What can we do with ToolBox? A lot of things! The main thing is we drag and drop things to form and classes. We do it like others (drag and drop) or with double click. She showed us how to use the Toolbox to effectively add a grid. It is much easier than other way.
What happens if we drag and drop something into program or we create file (modify file) and do the same thing? This drag and drop function is simply available for every application which drag and drop supports for example Microsoft Word or Excel and so on.
Tamar showed us how to add items at toolbox. The items are ActiveX controls, classes, files, scripts, text scraps. Everything of these was demonstrated on a lot of demos.
What about customizing our Toolbox? This was another Tamar´s topic. There are a lot of things what we can do with ToolBox and Tamar showed us how. We just need to open customize toolbox windows and there we can set for example:
- always on top,
- double click to open an item,
- allow toolbox to be minimized and many other things (filters, restore to default, determining the behavior of class items and so on).
At the end of the session Tamar was also speaking about Toolbox.dbf file:
- one record for each category,
- one record for each item,
and ToolBox.app file as well.
Tamar had a really demanding session with a lot of other topics (for example Builder Lock) including many demos which which showed how to easily solve each problem using Toolbox. Finally Tamar made a short summary of all things she presented. Great job, Tamar!
GUI – Uwe Habermann
The design of ergonomic user interfaces gets more and more important. This is reflected in several sessions.
In his session D-GUI Uwe explained in detail the to-dos and not-to-dos when designing user interfaces.
Uwe motivated the attendees to think in the way of end-users when designing user interfaces. The role of end-users should be involved in the whole development process. User interfaces must reflect the business cases of users. User interfaces must not reflect the data model or the point of view of the developer. This important point of abstraction is the challenge for developers when creating usable user interfaces.
Uwe showed how to create VFP 9 applications with user interfaces similar to Office XP applications using the native menu and a toolbar of VFP. The next example showed the Office 2003 layout made using DBI Sedna controls. The Office 2007 layout can be created using the ribbon bar example which can be downloaded from VFPX, which Uwe also showed.
Additionally, Uwe showed how to enhance existing VFP applications by adding nice layouts using GDI PLUS. While code examples for transparent forms and rounded forms are available on the conference CD, other examples for command buttons and any container background with color gradients can be downloaded from VFPX. Uwe also shows some nice business chart examples.
Introducing the Microsoft Entity Framework– Kevin McNeish
Microsoft always had a tendency to change the data access techniques every now and then. Some say it is like magic. New methods for working with data came every two years.
In .NET, the first option to connect to your data using ADO.NET is to use the untyped datasets. This is a common name for standard Data Sets and Data Table objects. The fact, that they are untyped, means that there are no special classes created for concrete tables in the database. Everything is just loaded into a generic Data Table objects.
The more advanced option, coming with Visual Studio 2005, is to use the typed datasets. This involves creating special classes that inherit from the generic ADO.NET objects based on the database schema before doing anything else. Once these classes are generated, they can be used to manipulate the data with a much larger comfort as well as with much higher chance the compiler catches any spelling error before runtime.
A whole new approach is to use the Microsoft Entity Framework. This technique creates a model, based on the database schema. This schema can then be edited, changed, providing for some flexible buffer room between the database schema and the entity schema. All other operations with data on the application side are then done by querying and updating the entities only, there is no access to the database itself. This provides the important shielding from minor database schema changes.
There are basically three methods that can be used to access the entities. These are the Entity client, Object services and LINQ to entities. Each and every one of these is using an SQL-like syntax when working with the schema. The most powerful one is obviously the last one, LINQ to Entities, and that is because its syntax can easily be checked by the compiler before even running the code.
Kevin showed all of the data access techniques on simple a Northwind examples and hence provided a short, but complete overview of how the data can be accessed in .NET nowadays.
Using VFPX Components in Production – Rick Schummer
This was a two part session on VFPX components, currently developed or being developed by the community on the CodePlex portal.
If you have not heard of the VFPX project yet, make sure you check out is website on www.codeplex.com. Basically it is an initiative to collect and develop various tools and components for Visual FoxPro in one place. Rick Schummer is the main administrator and coordinator of the project and used the session time to show us some of the cool stuff VFPX can offer.
Rick talked about Ctrl32_statusbar, which is a replacement for the standard VFP status bar. Is supports events, icons, etc. and can easily be placed on a form as well.
Desktop alerts is a new control allowing you to create bubbles similar to Outlook notification windows, which are shown when a new email comes in – a great replacement for the famous and grey WAIT NOWAIT WINDOW. Do not wait, use it right away!
There are also many other controls, such as the Outlook-like navigation bar, balloon tooltips, etc. Rick showed quite a few interesting components, what they can do for you, and how to use them in your code.
Introduction to Visual FoxPro 9.0 – Jürgen Wondzinski
Jürgen, aka wOOdy, started his session with a little survey that kind of belonged to the topic he was going to present. With its help he found out that there are people with little or almost no experience with VFP in his session, hoping to find out more. Generally, this was also their first DevCon here in Frankfurt.
After a short introduction of himself, wOOdy outlined the agenda of this two part session:
- Introduction into FoxPro in general,
- database engine,
- programs, classes and forms,
- menus, toolbar, etc.
The large part of the introduction evolved around FoxPro and Visual FoxPro’s history, starting with the VULCAN in 1979, through dBASE, FoxBase, FoxPro 1.02, FoxPro 2.5 in 1992, right up to Visual FoxPro versions finishing with version 9.
A certain feeling of nostalgia came, when wOOdy ran FoxBase 2.10 and FoxPro 1.02 products on his Vista machine. If you think now about FoxPro 1.02, just as I did in wOODy’s session, with its window-based environment, it is almost unbelievable that almost 20 years passed since its initial release!
The major milestone in FoxPro development is the time, when it was bought by Microsoft from the Fox Software company and immediately ported to Windows environment. First, it was a Windows 3.1 (3.11) version, later on Visual FoxPro 3 for Windows OS came in.
Another major point in FoxPro history is its version 7. At the time of version 6, Visual Studio products (Visual Basic, C++) were being ported under the .NET platform and an important decision involving VFP was made. It was decided, that Visual FoxPro will not be part of the .NET platform and will continue on as a standalone product.
This continued up to version 9, where Microsoft decided not to advance Visual FoxPro any further. Currently, there is a Service Pack 2 released and many community projects are running to continue extending the core of Visual FoxPro 9.
With Visual FoxPro a great emphasis was always laid on platform independence and backward compatibility. This is something that brought FoxPro its biggest success over the years and it is also what makes it live on and makes it being actively developed by the community.
Microsoft learned many lessons from the Visual FoxPro development and used them later on in other products as well (SQL server for instance). The product itself will run flawlessly on 64bit operating system in a compatibility mode and an extended support from Microsoft is promised till 2015.
The second part of the session continued with explanation of the Visual FoxPro own database engine, it strengths and flexibility, and the rest of the introduction as outlined in the agenda at the beginning.
Advantage Database Server for Developers – Doug Henning
Doug started his session with a simple statement: VFP is the best development environment on the planet. He also outlined, that a DBF database is very fragile and that this fragility is the main cause why companies do not want applications written in Visual FoxPro.
Doug introduced us Advantage Database Server (ADS). It is a true client server database engine which comes with a local or a remote engine. It is also possible to access an ADS database over the internet. The best thing is that we can use our VFP database and access it through the ADS. Doug pointed out one feature, which may be the most important one for us: ADS has more support for VFP than any other database engine.
If we open a VFP database in ADS then it is locked and we are not able to open via VFP and vice versa. Data on ADS are secured and encrypted as well. ADS have full transaction support and online backup.
ADS runs on Windows, NetWare and Linux as well.
Upsizing a VFP database was another Doug’s topic. If we want to upsize our database, there are couple issues such as:
- Primary key tags must have NOT DELETED () filter,
- General fields are not supported,
- It does not support format, field mapping, and field captions,
- Stored procedures are not upsized,
- Triggers are not upsized (because triggers are VFP code and not ADS code) and many others.
The session also gave us basics of how to access data in Visual FoxPro or ADS. The first way is using ODBC (DNS or connection string) and then we can use remote Views, CursorAdapter for example. When we are creating remote views we can use view designer, but there are also disadvantages such as we can not change an SQL statement dynamically, there is no DBC locking, only little control over updates and the like. The last option is to use OLEDB.
Doug did not forget to mention some features of ADT tables:
- No memo bloat,
- More data types (we do not have to use SeekUpper () and so on, it is Case-insensitive Char),
- Longer field names,
- Larger file sizes,
- More than 255 fields,
The session did not miss the speaker´s good mood, supported by a lot of handy informations about ADS. As a good speaker Doug did not forget to show us many instructive demos.
Using VFP with Sedna, AppScanX, VFP with VS, VSX, Vulcan.NET, and VFP Studio – Ken Levy, Bo Durban
The Keynote presented by Ken Levy in the morning was more of a slideshow. These two late night sessions are the continuing bonus ones filled with numerous demos.
There were many topics Ken touched in his sessions. He spoke again about the My namespace and NET4COM included in Sedna, as well as the VFPX project with reference to other sessions of the conference.
He spent much of the time with the AppScanX project he developed recently. In short, this is a tool for metadata-based code searching and reviewing. It could be used to find certain patterns in source code, to find security issues, or just to make statistics of how many times certain keyword or command appears in the code. Ken will be submitting AppScanX to the community as an open source project on http://codeplex.com/vfpx.
As Ken moved to Visual Studio examples, he mentioned www.visualstudiogallery.com website, where many of the tools and components, both free and commercial ones are grouped. It is kind of a home for Visual Studio extensions.
Before he let Bo Durban show some of the features of the new VFP Studio, he also talked a bit about Vulcan.NET, the Xbase family programming language for .NET, which allows working with DBF files in a much smoother way than pure .NET. Vulcan.NET is an extension of Visual Studio, which evolved both from Clipper and Visual Objects.
Next up in the demos was VFP Studio. In a short summary, VFP Studio is basically a VS IDE shell which has been extended in such a way, that VFP projects can be managed through there. It is based on Microsoft’s new license free and royalty free Visual Studio 2008 Shell. See http://msdn.com/vsx for more details on VSX. The ambition of VFP Studio is not to make something like a new VFP compiler or anything like it, the goal is just to take the advantage of the cool capabilities of the VS IDE and make them available for editing VFP source code.
As Bo was still up there, Rainer asked him if he could show again some of the examples involving GDI+ using the VFPX project called GDIPlusX. Bo replied like a true computer geek: “Sure, let me just grab my other laptop” and plugged in another one, when he continued with GDI+.
After Bo finished, Ken showed a few more demos including some just for fun like having an IE web browser ActiveX control on a form at the VFP screen as an interactive background or dragging and dropping a button on the VFP screen using the property AlwaysOnBottom.
Ken also gave a demo of the free EPS application called Xiine, see http://www.xiine. He also discussed how VFPConversion is about consulting services helping businesses who are moving VFP apps to .NET or integrating .NET into VFP apps. VFPConversion is also a portal website at www.vfpconversion.com with free content for VFP developers. Another link Ken referred to is CoDe Focus magazine issues at www.code-magazine.com/focus including 3 issues on VFP and 1 issue on VSX, and many others. Ken also mentioned he is now hosting a new CoDe Magazine podcast show with Markus Egger called CodeCast at http://codemag.com/codecast. The bonus sessions combined went 2 hours and 15 minutes, and while the demos were well received, the free beer was top highlight of the evening.
Friday, November 14
by Jan Vít and Jan Král
Creating Next Generation Windows Apps with WPF – Kevin McNeish
Kevin is the only person using iPhone in Frankfurt. At least if we trust all of the 20 visitors to his session who did not raise their hand when Kevin asked. But they all agreed that Apple is doing much better job than Microsoft when designing user interfaces. (This was also demonstrated later by a short video on youtube http://www.youtube.com/watch?v=nRKIDdIaFyE, after Kevin got his internet connectivity up and running.) Database developers usually do not like presentations that spend too much time dragging and dropping, drawing controls and make the form nice looking. When this is happening, they would start to ask “Where is the DATA?”. Although Kevin’s session was just about user interface, this time no one complained as Kevin clearly explained his view: users (our customers) do not care about how normalized our databases are or how state-of-the-art business logic we use behind the scenes. What they are interested about is ease of use and the way a software application matches the processes they do in their business. If an interior designer wants to show to his customer what would the room look like if they change a color of the wall or replace a piece of furniture, they prefer to use intuitive steps, such as picking another color from a palette or picking another bathtub from the catalog of pictures. And if the application helps with nice features such as zooming the picture as you move mouse over it, users will love it. An application like that (and more of similar ones) are included as sample projects in Microsoft’s Expression Blend 2. And, they use WPF, which is built on XAML.
WPF replaces Windows Forms. Unfortunately, there is no migration path from Windows Forms into WPF. But there is a reason to leave Windows Forms after we find out that WPF is not just another fresh new technology by Microsoft. The reason is that XAML is also used by Silverlight 2.0 (a mature ancestor of Web Forms) and almost all of the functionality is transferable between Silverlight and WPF.
From an architectural point of view, the nice thing about XAML is that it allows a designer to use Expression Blend to design UI and the XAML code can be used by Visual Studio 2008 seamlessly. This is true vice versa, too. Interestingly enough, databinding is much better in Expression Blend 2 (June CTP) than in VS2008!
Oh, and what was the main content of the presentation? Kevin learned attendees how to use Expression Blend to built a “Windows Forms” application that presents the same UI as an iPhone. This way he showed how to build appealing modern interfaces using VS2008 and Expression Blend.
We Used to Do it That Way, But… –Tamar Ganor
It is the second day of our conference and we are back again to listen to Tamar Granor. This time the session was focused on string manipulation, working with data and programming techniques.
Tamar started with strings. This topic was the main reason why she decided to prepare this session. She showed us how effectively use command JustStem (), JustPath or JustExt (). Another command which can make our developer lifes easier is ForcePath (). Tamar said clearly: it is fast and easy! Then she moved to reading and writing functions. The example she showed us was dealing with FileToString (), which is always faster than low level functions.
What about parsing? Parsing was another thing Tamar was talking about. She quickly explained the difference between MLines() and ALines() and showed thta ALines () is faster than MLines(). Much more was said (Textmerge, Cast()…), but that would be for a longer article.
Another Tamar’s topic was working with data. Just at the beginning she mentioned one important thing: “Always use alias to refer to a work area”. We should use USE IN and alias parameter whenever we can. She put a big accent on that.
The last thing Tamar was talking about was programming techniques. She started with Name expression, Eval () or Macro (). She showed us how these commands are working and how to effectively and correctly use them. Then she moved to DO WHILE and SCAN, showing us what happened when we used them with Set Order command and how fast they are. She advised us, when we need to use loop, to choose SCAN with If command, because it is much faster than DO WHILE.
After that the session focused on Variables. Tamar told us that Local Variables are the best choice (available only in current function or method…). If you were scared that she would forget Private or Public variables, than you were wrong, she made a brief overview of them. Array was also mentioned in Tamar’s session. Array we should use is the local one. The very important thing is that we should use parameters.
At the end Tamar said tree things:
- newer ways can be faster,
- newer ways can be more readable,
- aim for best practices
This session was for everybody who wanted to share and get new experiences from a great speaker, who Tamar definitely is. Of course Tamar didn’t forget to demonstrate all of these on great demos, which were short and simple for understanding.
Guided Tour of Visual Studio 2008 – Kevin McNeish
Visual Studio 2008 is the newest version of Visual Studio. Compared to its predecessors, the IDE is much more developed and thought-out. In his session Kevin started right from the beginner’s point of view.
If you‘d like to start a new project in Visual Studio, the first thing you have to do is creating it. There are many project types that can be created. These are for example the Windows application, Web application, Class library or a Console application. What is different among these is the type of the output file. In is either an EXE file, DLL file or a web application.
Once you have your project created, it is important to manage it and navigate through its content. Kevin showed many of the tips and tricks for doing so, including some of the less familiar keyboard shortcuts. He also familiarized the audience with many of the tool windows within the Visual Studio IDE. The Server explorer is used to access your database (an SQL server for instance), its tables, views, stored procedures, etc., right from the Visual Studio. There is the Class viewer providing a namespace ordered list of all the classes in your project and the toolbox for adding components and code snippets to your application.
Murphy’s laws are everywhere: As soon as you create the first pieces of code, you are likely to find out, that you didn’t arrange it in the very best way. This is when the refactoring comes in. Visual Studio has many powerful features in this area, allowing you to extract a method, encapsulate a field, reorder parameters, etc.
Another great feature that makes a developer more productive is the code snippets. These are the self-expanding keywords, like “if” or “for” that after you hit the TAB key twice, you get the required command structure. You can also easily create your own code snippets using the code snippets manager.
Kevin continued with many other topics, such as automated code formatting, change tracking, debug visualizations and spent quite some time with the class designer, which he personally likes a lot.
At the very end of the session Kevin also lightly scratched the surface of debugging and unit testing.
Creating Explorer Interfaces in Visual FoxPro – Doug Henning
Explorer-style user interfaces are recently becoming more and more popular. Even though they won’t suit every application, there are some, mainly those presenting hierarchical data, that might benefit quite a lot from this type of GUI. If you are thinking of creating such interface in Visual FoxPro, it is clear that the standard set of controls will not suffice. This session discussed the right controls that should be used for this, their advantages, disadvantages, issues to be aware of and how to utilize them in Visual FoxPro applications.
We will need a control to show the list of items. The most usual one is the TreeView control. Once an item is selected in the TreeView, we need a way of displaying its properties. To make the GUI complete, we also have to add some kind of a splitter and an interesting status bar to it.
So, which TreeView we are going to use? The first thoughts may lead to the MS TreeView control shipping together with VFP. According to Doug, this is not the best option. The MS TreeView has quite a few issues. It is deadly slow when loading more than a few nodes. It doesn’t respect the LockScreen setting, right clicking a node will not activate it, the double clicking a node will always toggle its expansion no matter what you would like, etc.
A much better tool to use is the SFTreeViewContainer. It resolves all of the issues mentioned above and provides many more improvements suitable for explorer-style interfaces. With help of additional controls and control sets like SFTreeViewCursor, SFExplorerForm or VFPX controls, Doug was able to duplicate the Outlook-style GUI and also made partially data driven.
If you are considering the explorer-like interfaces in combination with Visual FoxPro, these classes can really be of help.
PDA development with Guineu – Christof Wollenhaupt
VFP running on a PDA? Could this really be done? If you have heard about the Guineu project, developed by Christof Wollenhaupt, you know this is already possible.
To make a long story short, Guineu is basically a .NET CRL compiler written in C#. It takes the FXP files and executes them under.NET. Just as .NET, Guineu is also multi-platform and therefore can run on windows mobile devices as well.
What is presently available in Guineu is a number of controls, full read access to DBF, limited write access to DBF files, forms, PRGs, classes and extra SYS functions.
The project is still in its early phase of development. It can however already be used to solve real world problems. Just keep in mind, that not all VFP commands are supported yet as well as that there are some reserves as far as the performance is concerned.
To prove the theory behind, Christof actually created and ran a Guineu application in a mobile phone environment directly during the session.
If you have a need for a mobile device application presently, you have several options. You can go with learning and using C++, .NET compact framework, Java, use web applications or, if you know VFP, you can give Guineu a try. There are already certain situations where it just fits the needs on PDAs, mobile phones, embedded systems or barcode scanners.
Rich Internet Applications in Silverlight 2.0 – Kevin McNeish
The first historic idea for web was to offer mainly the text-based information in a static format. Later on, some of the graphics followed and the need for dynamic pages appeared. From CGI up to ASP.NET, the web still was not as flexible as the Windows Forms environment. This was partly compensated by using the asynchronous JavaScript and XML (AJAX), but the web was still behind.
The new Silverlight technology is out to change all this. It promises a unified user experience, no matter what presentation technique is used. There is a new XAML language which translates to both, windows as well as the browser environment.
Another important change being introduced together with this technology is that the graphic design is easily separable from the code. In fact, there is a whole new tool called Expression Blend just for creating the graphical part of the GUI.
The Silverlight applications have to be compiled and need a plug-in on the client side. This plug-in is actually a very small one (less than 2 MB) and can be downloaded on demand, when there is a Silverlight application that needs to be run.
So, how do we develop these applications? I have already mentioned that the GUI is developed aside from the code. Expression Blend creates an XML file, called XAML, which includes all of the information about the application graphics and GUI arrangements. Then, using the familiar languages like C#, VB.NET or other .NET languages, the graphics becomes alive with help of the code.
There are already many controls available for Silverlight as well as the support for data binding is finally complete. If you have been skeptical and were waiting to start using this technology, now is the right time. The WinForms technology is not being developed any further and it is considered at the end of its evolution path.
Kevin continued his presentation explaining the individual details of creating and hosting Silverlight applications, showed what it takes to work with Expression Blend, and used many demos to properly demonstrate his points.
There are also two more technologies Kevin mentioned during his presentation. One is Deep Zoom (http://memorabilia.hardrock.com), the second one is Microsoft Photosynth (http://livelabs.com/photosynth). Both can do wonders with graphics, they are both worth checking out on the links provided.
VFP Compiler for .NET, .NET Extender for VFP – Markus Winhard
Markus Winhard gave sessions on the two products of eTecnologia.
First he briefly showed how to use the .NET Compiler for VFP in the VFP 9.0 IDE. The rest of his session was demoing eTecnologia’s new development environment for VFP.NET, the VFP Developer Studio. You can create VFP.NET solutions targeting the Windows desktop, console applications, ASP.NET applicatons and DLL projects. If you like you can also code WinForms applications using the visual designer and VFP language. While eTecnologia is currently working on the designers for VFP forms and visual classes the compilation of VCX and SCX files into .NET EXEs and DLLs is already supported. There was also a first demo of a Windows Presentation Foundation (WPF) form designer and a little WPF project that displayed and edited data from VFPs Northwind sample database. Depending on user demand eTecnologia will also target Silverlight 2.0 applications. There was also an announcement that eTecnologia will assist the german VFP usergroup in the conversion of their framework Visual Extend (VFX) for the VFP.NET platform. At the end of the conference there was also the demand for a whole day track on the VFP Compiler for .NET at next year’s german VFP developers conference.
While the VFP Compiler for .NET is considered as VFPs future by many VFP developers, there is also a product that helps VFP developers today. You can use eTecnologias .NET Extender for VFP to build hybrid applications that are using both VFP and .NET. Beneath a bunch of samples how to make use of visual and non-visual .NET classes in VFP 9.0 applications Markus Winhard showed parts from a productive VFP 9.0 application. It is using eTecnologia’s .NET Extender for VFP to call third party .NET classes and self made C# classes. He also showed the inner workings of the VFP classes that build the glue between eTecnologia’s NET host and VFP and how to use them in your own applications.
Saturday, November 15
by Jan Vít and Jan Král
The Datasession – Venelina Jordanova
The end of the conference is slowly approaching, but before the conference will be ended, we have some more reports. This time we visited Venelina’s session which was about working and optimizing datasessions.
At the beginning Venelina made a quick and brief overview of the agenda which contained topics such as:
- data retrieval control,
- using parameters,
- overcoming VFP limits,
- CursorAdapter
All the time when we are programming a software we usually, somehow, work with data. The question is how to retrieve the data? At first Venelina advised us not to use VFP CA Builder and gave us a reference to great website about connection strings http://connectionstrings.com. Then she continued with comparing two ways how to connect to our data. The first one was ODBC which was demonstrated on short demo where Venelina explained how to use SQLSTRINGCONNECT() or SQLCONNECT() . After that she moved to the second possibility which was ADODB, but she prefers using ODBC for its reliability. When this topic was discussed she added some notes about controlling data retrieval using methods such as CursorFill (), CursorRefresh () or properties UseCursorSchema and NoDataOnLoad.
Another topic of Venelina’s session was parameters. She explained us basics in using parameters and pointed out their importance. For example we should be sure that all our parameters exist and have a correct value at the time when object initializes and so on. Parameters can also be powerful weapon on field of security of our data which is very important for companies, because they want to let their employees or customers access only some sort of data and other data must be restricted.
The session was also about large data amount. Working with a large ammount of data sometimes can be a little tricky. Venelina advised us to split the data in our table into one or more cursors and manage the relations between them.
At the end of the session we moved to the last topic which was the CursorAdapter. Venelina showed us how effectively and without any problems we can use CursorAdapter and she pointed out some advantages such as keeping data integrity and handling retrieval and update errors.
Venelina had done a great job. The sessions gave us a lot of handy information supported by simple and a well understand demos. At last she also showed us funny video corresponding to CursorAdapter.
Creating Custom Report Controls with Sedna – Bo Durban
The report writer was one of the last extensive improvements in Visual FoxPro 9.0. In fact, it has been completely rewritten with the extensibility in mind. There are many events to hook into and the report listener class now provides even more flexibility.
Other enhancements came with the SP2 for Visual FoxPro 9.0 and more and more is still happening around the VFP reporting as far as the VFPX and some vendor products are concerned.
Bo began his session with an overview of the improvements in version 9.0 and compared those to the previous versions. SP2 fixed some of the bugs, increased the report engine performance, brought the FX and GFX classes and made sure the backward compatibility is maintained.
The rest of the session revolved around countless examples of wonders the report engine can provide, if properly used. Some of the examples were quite complex, as they usually are, when the new report engine is being talked about, but showed its almost unlimited graphics possibilities.
At the end, Bo shared his outlook of the further of VFP 9.0 reporting. According to him, the future lies with the VFPX project and other 3rd party tools like Moxie Objects, XFRX, Minds Eye, Stonefield Query or Foxfire!. The future of VFP reporting is still exciting.
Practical uses for XML – Doug Henning
In this session beginners to XML felt good as Doug chose to start in a slow motion and explained the basics first. This way attendees were reminded how “well formed“ XML document should look like and that this does not to be confused with a “valid XML” document. Encoding, element centric vs attribute centric XML and schemas were demonstrated as well. As the session was the first after lunch, a short test of how awake attendees are was included. Rick S. seemed to be ready to give correct answers from the back of the room.
When dealing in VFP with XML there are many instruments available and it is always good idea to refactor the ways we used when we started handling XML documents in VFP years ago. Instead of creating XML “manually” using TEXTMERGE, for many situations CURSORTOXML is enough and more convenient. If the document includes hierarchy, XMLAdapter should be taken into account. And as this class uses XMLDOM internally, why don´t we use XMLDOM directly, if it comes to the most complicated XML scenarios?
As with many similar tasks, the most important part is “How do I create a reference to the right tool using CREATEOBJECT?” So here is the line of code:
- CREATEOBJ(“MSXML2.DOMDocument.3.0”)
Now as we have an overview of possible ways to manipulate XML in VFP, Doug showed examples of various typical uses of XML with VFP:
- Instead of storing binary information (of properties, settings) in memo fields it is much more readable (if this is what we prefer at a given situation) to use XML instead.
- Same applies if we consider to store .INI type sets of parameters (which are not designed to include hierarchies unlike XML)
- Many applications today use XML as a way to communicate through their API (e.g the contact management CodeMine can accept contact details in XML doc)
- Interesting scenario is integrating RSS readers directly into our application, allowing our users to receive timely information from our blogs, instead of relying on their ability to configure RSS feeds on our blog site.
Extending the Sedna Data Explorer – Rick Schummer
Another today’s session was held by Rick Schummer. At the beginning he introduced himself and in a while he continued with what Data Explorer is and what is new in Sedna (expecially second editon of Data Explorer, the first one was in Visual FoxPro 9.0).
The first thing Rick pointed out was that Data explorer is going to be installed under sedna folder which is situated under the VFP folder. After that there are couples of ways how to start it:
- run old and new version from a Command Window,
- copy new version into VFP folder (lose the old one),
- create alternative InteliSense script (DX)
- TaskPane manager.
The biggest feature in Data Explorer is the possibility to change settings and adding the things we want. If we are working with tables we can browse them or we can run query and many other things. Most of the features is saved in DataExplorer.dbf file. In option dialog we can manage menus, add-Ins and restore to default. If we choose restore to default we will loose our features. This is nice when we want to start from the beginning.
What is new in sedna version? The Main Form is a little bit different; we can run GenDBC, Database Documenter, Bug fixes. In the Main Form, there is a new refresh button, which is handy when we want to refresh our connections, option button when the option window pups up and there is some new features as well (button style for main toolbar, Rushmore query optimizing level, etc.). After that Rick showed other features in this window such as menu manager. Rick stressed one very important point, do not forget to BACKUP, BACKUP and BACKUP again.
Rick continued with Database documentation feature. This feature creates an html file with information about our database. The great thing is that in Menu Manager we can change the color of caption and many other things. Also Query dialog has few changes. We can script couple of queries in one dialog window without any problems for example.
Rick then moved to Add-Ins manager where we can add in things which can improve our developer’s productivity. Rick proved this with a lot of simple and nice demos.
Rick’s session was full of tips and tricks on how to improve our Data Explorer. We have definitely enjoyed this session. Thank you Rick.
Automated Builds of VFP applications – Markus Winhard
Markus Winhard’s third session was about continuous integration (CI) the VFP way. He talked about why you should do it, the tools you already have and the free tools to complement your tool set, and how you should do it.
He also showed how to install and configure a build server in less than 15 minutes. In his sample setup he was using Visual SourceSafe, VFP 9.0, CruiseControl.NET and a build script written in VFP. The shown configuration is in production at two sites since a few months.
There will be a new project on VFPX called Automated Build where you can download his stuff.
Using .NET from Visual FoxPro – Christof Wollenhaupt
In the time of FoxPro for DOS, it was very difficult to access a functionality which was not an integral part of FoxPro itself. If there was a barcode reader or a credit card reader which had to be connected to the FoxPro system, one had to use FLL libraries or BIN files to reach it. Together with Windows, other possibilities came. With Visual FoxPro we can access other functionality through Windows API or COM. Nowadays, the hype lies with .NET and this session explored various ways of getting some of its functionality back to FoxPro.
The first step in exposing some of the functionality from .NET to Visual FoxPro is to write some kind of a wrapper for this directly in .NET. One can create .NET code in several ways. The most marketed way is of course to buy and use Visual Studio 2008 IDE. For occasional programming however special free Express editions can be used as well. This provides intellisense and other features for productivity boosting.
What is important to realize is that the Visual Studio is just an IDE, not the compiler. The compiling can be done with help of the command line and the compiler itself is distributed for free. If you consider yourself a VFP purist and would like to develop your .NET application in a VFP IDE, you can certainly do so. Just open up a new file with MODIFY FILE, write the code and then USE RUN CSC.EXE for compiling.
Later on Christof described and showed various ways of interconnecting .NET and VFP. One of the most obvious ones is to use the .NET COM Interop and create a COM server out of a .NET assembly. This can then easily be called from within Visual FoxPro to access the required functionality. A more advanced approach showed, especially handy when multi-threading is needed, uses sending messages through Windows SendMessage API. In this case, VFP was listening to a .NET application through BINDEVENTS while.NET was sending the required data.
The closing session – Rainer Becker
All good things have to end. After three days full of attending sessions, talking to other developers and most importantly having fun, the end of the conference is closing by. There is only a room for the very last session, the closing session.
Last year, we have seen many community projects, like VFPX, Guineu or .NET Compiler being developed. This year, we had an opportunity to see its recent state of development. Even though the attendance of the conference lowered, as we have already mentioned in the KeyNote, Rainer is already looking forward to another conference year.
The closing session wrapped up with a traditional raffle where the lucky ones were given several computer products from the conference sponsors. Our congratulations!
Final Words & Acknowledgements
At the very end, we, the reporters, would also like to say a loud “Thank you” to all the people, who has helped us to make the report as comprehensive as possible. Our thanks go to:
Rainer Becker, the organizer of the whole event, the key person who has continuously been looking after all of the small details that made our work as reporters as well as our stay as attendees as comfortable as possible. Thank you, Rainer!
Michel Fournier, the inventor of the UT reporting, who has always been very forthcoming and realized all of our various reporting requests in the blink of on an eye. Thank you, Michel!
Tina, Rainer’s right hand, who has always been making sure that everything went as smooth as possible and that all the attendees were feeling comfortable. Thank you, Tina!
Uwe Habermann and Igor Vít who helped us with the reporting a lot by providing several ready-made texts.
Venelina Jordanova and Uwe Habermann for quite a few pictures for the picture archive. Thank you!
Lovely hotel personnel, who were always there to take care of us as well as every other attendee.
Our extended gratitude goes also to many others, who have made our reporting job easier, if only by creating a wonderful place and atmosphere to be in and where everyone was smiling when we pulled out our cameras. Thanks to you all! Feel free to share with us your experiences from the conference, any notes on the reporting as well as your ideas of the UT coverage improvements. We are always happy to get the feedback from you!
See you next year!
 |
| |||||
 |
| |||||
62 Rue Doucet, Petit-Rocher, New Brunswick, E8J 1L3
Telephone: 1-506-783-9007 Email: mfournier@levelextreme.com
