Monday, November 12, 2007

RoloFlex Release: Press Release and Marketing

RoloFlex 12.5 Released November 2007
Featuring Visual DataFlex

Rated highly by submission to download sites listed herein, the RoloFlex CRM/PIM [customer relations management/personal information manager] is going out to major download sites and features the upgraded RoloFlex product released with the Visual DataFlex 12.1 platform.

The marketing effort for RoloFlex is just beginning!

Soon, RoloFlex will be available at most major download sites featuring anonymous download under the Visual DataFlex 12.1 evaluation period and subsequent registration/licensing when registered through
Under Construction: RoloFlex Time Tracker 12.5 for billing hours and invoicing.
Nearing Release Now: RoloFlex EMail Module, due for distribution on November 15 2007
Please Note the RoloFlex Blog Site for future news!
Sincerely, Peter and Kimberly Donovan

Tuesday, October 09, 2007

DDO Tree Technology – DAF Methodology

DDO Tree: A combination of instantiated data dictionary objects tied together.
DAF Methodology: How the ddo tree handles find, clear, save, delete and validation.

Here’s a sample (simple) ddo tree as found in a sales order data entry program or other module…

“Knowing how the ddo tree handles user requests is at least important to know as how to model a data dictionary class”

Communication between the ddo tree and the objects in play is a two way street!

In this example of data entry, the Server of the main panel is Salehead and it controls the find/clear/save/delete and validation of itself and all it’s parent ddo objects.

In a lesson in polymorphism, the “Customer” ddo recognizes it is a parent object of the server in play, and enforces different rules (find required on record for instance) than it normally would if it was the server itself.

Further, the SaleHead ddo takes responsibility for accepting the find/clear/save/delete messages sent via the user. When the cursor/focus is in the customer name window, for instance, the request_find message actually goes directly to the SaleHead ddo, not the Customer ddo. The SaleHead realizes that the message is directed at a parent ddo and forwards the message up thru the connection to the Customer ddo to handle.

Take your data entry module with parents and put a hook message inside the server and the parent “request_find” method and see which pops up first!

In the same way that this communicates upwards, it also communicates downwards so that when a delete message comes to the server, it travels downwards, deleting all children of the server and then itself. The beauty of the methodology is that no parent records can be deleted by the user unless programmatically allowed by the software engineer.

Take any data entry module, place the focus in a parent object cell or window, and press delete. What get’s deleted? Not the parent!

So, augmentation of ALL find/clear/save/delete requests can be done at the server level! Here’s how to code so the customer of an order cannot be changed:

Object Customer_DD is a Customer_DataDictionary

Object SaleHead_DD is a SaleHead_DataDictionary
Set ddo_server to Customer_DD
Procedure Request_Find Integer iMode Integer iFile Integer iIndex
If ((iFile = Customer.File_Number) and (Current_Record(Self))) Procedure_Return
Forward Send Request_Find iMode iFile iIndex
Procedure FindByRowID Integer iFile RowID riRowID
If ((iFile = Customer.File_Number) and (Current_Record(Self))) Procedure_Return
Forward Send FindByRowID iFile riRowID


This is one correct way to code a sales order so the parent cannot be changed of an existing sales order!

So, what have we learned? DAF Methodology.
It’s a study of communication between data entry objects which delegate user messages to the server, and how that server communicates the messages to it’s parent and child tables.

Wednesday, October 03, 2007

Visual DataFlex DDO Tree Technology Reference

A Reference Guide of DDO Technology
– Visual DataFlex–

Outline Mode:
- Introduction
- Terms
- What is a DDO?
- What is a DD Class?
- What is a DDO Tree?

Based on DAF Methodology, the DDO Technology in Visual DataFlex is a study of instantiation, delegation, and polymorphism.

Instantiation: The act of creating an object based on a class and class hierarchy.
Delegation: Visual DataFlex features natural full delegation of methods by default, where the method travels first to the object, then to it’s superclass, and on throughout the full class hierarchy until the method is resolved. A method runs to completion without augmentation or definition on the object level but such augmentation, forwarding, or canceling is supported on both the class and object level.
Polymorphism: The act of an object to produce different behavior depending on it’s context.

What is a DDO?
“data dictionary objects” are instantiated in each data entry (or other type) module for the purpose of:
- Providing a “server” for find/clear/save/delete and validation operations for a data table.
- Providing data aware controls with attributes such as capslock, valid values, default values, range definition, selection list definition, etc.
- Communicating with other DDO’s in tandem to do all of the above with coordination.
- Definition of “constraint data filters” where your data can be a subset of the whole.

Sample Object Code:
// doc: instantiation of customer_datadictionary class placed inside panel of data entry form.

Object oCustomer_DD is a Customer_DataDictionary // instantiation of class.
Set DDO_Server to oSalesRep_DD // parent or “server” ddo
Set DDO_Server to oTerms_DD // parent or “server” ddo
Procedure OnConstrain // predefined method
Forward Send OnConstrain // continue delegation
Constrain Customer.Active EQ “Y”
Constrain Customer As (Customer.TotalOwed What is a DD Class?
A data dictionary class is a number of things: about 10 major functions with more omitted for space constraints in this article.

[1] A Data Dictionary Class defines the attributes for the data table to be communicated to the data aware controls tied into that database table. Attributes include “capslock”, “required entry in this column”, “auto-find upon exit”, “shadowed/non-enterable”, etc.

[2] The DD Class sets the (above noted) attributes differently depending on whether the ddo (instantiated object based on the class) is the direct server of operations, or a parent ddo of the operations server. This creates polymorphism on the object level and allows parent records to be found, required to be found, but not allow changes, for instance.

[3] The DD Class defines which other database table objects must be instantiated alongside with it to perform save and delete operations. For instance, the save of a sales order lineitem would require a dd object (ddo) for the product it was related to in order to reduce inventory or create a backorder. In another instance, the sales order header would require a ddo for the sales order lineitem to be present in order to delete the related order lineitems. Also, a DD Class may be configured to not allow deletes if child records exist.

[4] The DD Class allows columns to be associated with a “selection list” or lookup object. The chosen selection list will create a lookup button on the control chosen for that column and automatically popup and communicate two ways with the selection list.

[5] The DD Class allows the database programmer to define the object labels for each column and also to default the creation of controls for this column to a certain type such as a spinform or comboform, etc. (communication with the visual dataflex studio).

[6] The DD Class features augmentable save, find, clear, delete, and validate methods. The operations server (ddo) in a form or “view” will initiate a cascade of messages designed to perform an operation such as a save operation. When this save occurs, it cascades to all the connected data dictionary objects in the form or “view” which then delegates to the DD Class where you can augment the operation based on business rules you define and business rule exceptions which can be controlled via various means, usually with a property setting.

[7] The DD Class allows the setting of “valid values” validation tables which accompany a column in whatever control form it takes (regular form, comboform, or in a grid). The DD Class can define a list such as “activeinactive” for itself, or share a validation table with other DD Classes such as a list of US states or valid shipping terms.

[8] The DD Class allows for the definition of entry and exit methods for each column of the database table. Whether the column, in data entry, is represented in a comboform, or in a grid, the entry and exit methods follow it.

[9] The DD Class allows for auto-incrementing from a “system file” for ID fields, for instance or lineitem numbers.

[10] The DD Class communicates when instantiated, to validate the find/clear/save/delete cascade of messages along with whatever other ddo objects it is connected to.

What is a DDO Tree?
Data Dictionary Objects are run in tandem to find/clear/save/delete and validate these operations.
Let’s take a sales order entry application for example. The business rules given to you are;
· Customers who are not active may not purchase.
· Active customers may not go over their credit limit by more than 10%.
· Sales orders update the customer total owed.
· Lineitems update both the sales order total and reduce product from inventory.
· Product records update vendor purchase history.
· Sales orders update the salesrep volume sold.

Here’s a sales order entry application ddo tree (simplistic) example:
// doc: ddo tree for SO application
Object oTerms_DD is a Terms_DataDictionary

Object oSalesRep_DD

Object oCustomer_DD is a Customer_DataDictionary
Set DDO_Server to oSalesRep_DD
Set DDO_Server to oTerms_DD
Procedure OnConstrain
Forward Send OnConstrain
Constrain Customer.Active EQ “Y”
Function Validate_Save Returns Integer
Integer iReturnVal
Forward Get Validate_Save to iReturnVal
If (Customer.Owed > (Customer.CreditLimit * 1.10)) Error 999 “Customer Over Credit Limit”
Function_Return iReturnVal

Object oVendor_DD is a Vendor_DataDictionary

Object oProduct_DD is a Product_DataDictionary
Set DDO_Server to oVendor_DD
Procedure Update
Forward Send Update
Add (Product.Qty * Product.Price) to Vendor.Volume
Procedure Backout
Forward Send Backout
Subtract (Product.Qty * Product.Price) from Vendor.Volume

Object oSaleHead is a SaleHead_DataDictionary
Set DDO_Server to oCustomerDD
Procedure Update
Forward Send Update
Add SaleHead.Total to Customer.Owed
Add SaleHead.Total to SalesRep.Volume
Procedure Backout
Forward Send Backout
Subtract SaleHead.Total from Customer.Owed
Subtract SaleHead.Total from SalesRep.Volume

Object oLineItem_DD is a LineItem_DataDictionary
Set DDO_Server to oSaleHead_DD
Set DDO_Server to oProduct_DD
Procedure Update
Forward Send Update
Add LineItem.Total to SaleHead.Total
Subtract LineItem.Qty from Product.QtyOnHand
Procedure Backout
Forward Send Backout
Subtract LineItem.Total from SaleHead.Total
Add LineItem.Qty to Product.QtyOnHand

With a pictorial version of what’s happening in the tree:

Thursday, September 27, 2007

RoloFlex Companion #1

The first RoloFlex Companion Product *for Professional Version Only will be Launched on November 15th.

Contributed by longstanding custom app developer Garret Mott of Auto-Mate Software.

Note: Garret has done a number of custom email managers, adding in features such as disclaimer, logo as an image, signature with custom field placement capability, attachments, well... it has a lot of features. Any developer looking for a custom email attachment to their product please contact

Note: This is intended as a launch of companion products, both for RoloFlex, and a platform for getting your Visual DataFlex product out in a new market. Please contact for more details and a prototype agreement.

Thanks! Good luck to the pooch - "Rolo".

Saturday, September 22, 2007

www.RoloFlex.Biz - New Home for RoloFlex

RoloFlex: now 2 flavors:
Personal and Professional
*The professional version simply has a valid VDF client license sold for commercial/business clients.
The new home is:
And a more professional interface is coded to accomodate the release.
Regards, Peter & Kimberly Donovan

Friday, September 21, 2007

A guide to discovering the Visual DataFlex Studio

A beginner’s guide to coding a custom database application in *Visual DataFlex
by Peter A Donovan/Applause Software/Boston.

*Visual DataFlex is a trademark of Data Access Worldwide of Miami.

Here’s a conceptual step-by-step methodology for creating your first Visual DataFlex application.
Visual DataFlex is a “transparent back end” database application studio where the same exact code runs on your choice of backend.
This overview assumes you will start with the native DataFlex backend as a starting point.
To encourage you to try the Visual DataFlex studio for a test drive using [freeware] the Personal DataFlex edition licensed for personal but not commercial use.
This is a full studio deploy with no restrictions other than mentioned above.
Compelling Reasons:
You can most likely produce a fundamentally solid application in ½ the time as your current studio.

First, let’s assume you have the studio downloaded from and you are running on a 30 day eval prior to getting a license.

If you fire up the Visual DataFlex Studio, you’ve got the “order entry” sample example workspace automatically loaded for you, and the current project is “Order.src”. From this point, you should hit [F5] and the “source code = src” will compile into an executable and run. Please check out the features of the running program. This, we will code ourselves in a new “SRC” project to see how it was done.

1. From the menu, choose File-New-Project-Windows Project, and you will get a dialog asking for the .EXE name. Please type “Test” and press ok.
2. For fun, just hit [F5] and compile an executable, which you will find is a perfect MDI [multiple dialog interface] container with no functionality BUT… the button bar, menu headers, and runtime are all done.
3. Back in the Studio, let’s create a data entry program or form if you will. Click File-New-View/Report-Data Entry View Wizard, and click Ok.
4. From the wizard, click “next” on the opening page.
5. For an object name, please enter “oSalesOrder” and accept the defaults for the next 2 windows and click “next”.
6. Next page: change the radio button please to select “create a header-detail entry view” and click “next”.
7. Now, the time has come to select the CHILD table for the data entry view, so highlight “OrderDtl” and click “next”.
8. For the “header” data table, we will select “Orderhea” and click “next”.
9. Now, we select the columns “fields” to show in the data entry HEADER section, and I recommend: Choose ALL the columns from the OrderHeader table EXCEPT the last one [last detail number] and click “next”.
10. Now, we select the columns “fields” to show in the child grid below the header, and I recommend: Choose ALL the columns [except for the FIRST : ordernumber] from the detail table and click “next”.
11. Next, you get to customize the labels for each of the forms if you like, but the default has already been programmed into the datadictionary, so simply change the radio button to “right” justify the labels, and click “next”, and “Finish”.
12. Press [F5] which auto-saves and compiles your SRC into a EXE and test!

You now have a running program [under the view menu] which actually saves sales orders and detail lines. Not the most appealing visually, but structurally sound.
You will find that there are entry methods associated with some database columns, and exit methods associated with some. You MUST find a parent table record in order to save, and you MUST fill in some required fields. There’s a snazzy lookup list [expandable] for each of the associated tables, and some columns automatically are instantiated as comboforms for you automatically. A couple of small modifications later and we are on the road to deploying this. [omitted].

This is just a sample of the power of Visual DataFlex, and a few words of explanation are required to answer questions that this may have raised.

* The datadictionary for each of the tables has been pre-coded for you in this sample example.
* The datadictionary for the parent tables adjusts automatically, knowing that it is used as a parent reference, to be “find required” in an excellent display of polymorphism. The same exact table behaves differently when it is the main table for data entry, i.e. no “find required”.
* The key fields/columns of each table cannot be changed: they are protected from change via a checkbox in the datadictionary.
* The labels for each column are configured in the datadictionary so they appear consistent throughout your application.
* The lookup lists, called selection lists are assigned to a table-column in the datadictionary so they automatically appear with a prompt button with no code.
* The Order Header TOTAL automatically adds and subtracts based on what you do with the lineitems: delete/save new/change.
* The Product on_hand total automatically adds and subtracts based on what you do with the lineitems: delete/save new/change.
* For a real LASTING impression of visual dataflex, please note the quantity onhand of a lineitem product, and then CHANGE the product in the lineitem without changing the quantity. * Then, choose the lookup, and you will see that the lineitem quantity has been moved back INTO inventory for the product you changed. Note: there are about 5 lines of code in the datadictionary that make this happen!
* Now, for real fun…, place the cursor in the header section on customer and choose DELETE from the button bar. Surprise, the customer is not deleted but the entire order and all of it’s lineitems are deleted. Repeat: place the cursor on the product code column of an existing lineitem and hit DELETE. The product is not deleted, but only the lineitem.

By this point, you may be ready to give the datadictionary a once-over!
From the Studio, select Tools-Database Builder. This utility creates the CLASS that each datadictionary object [in your entry form] is based on.
From the “Open Table” pulldown, select “Order Header” and browse thru the settings. It’s extremely impressive I think in the maturity of the product.

Ok, you want to give Visual DataFlex a shot, but where do you go for help?
The Visual DataFlex newsgroup: The url is: news://
Please introduce yourself as a new developer and we will welcome you with advice and support.

Thanks for giving Visual DataFlex a trial, and look forward to seeing you on the newsgroup!

Peter A Donovan of Boston, USA

The Agile Manifesto

Quick Note:

This morning, I read one of the greatest blog articles by Joe Coley of the NEDC. In a newly opened blog, Joe's article just posted features the AGILE MANIFESTO which is an incredibly poignant statement about software development philosophy.

I recommend checking in on Joe's blog as a "must read"-

Joe's photo and background can also be found at:

PS: You can become a signatory of this manifesto if you agree with it's content.

Thursday, September 20, 2007

Publising an article about Visual DataFlex

Publicity for Visual DataFlex:

I am writing this article specifically geared for Visual DataFlex developers who would like to write an article publicizing your views or information about visual dataflex...

I personally have tried to publicize VDF thru article writing, and posting to different sources, and would recommend the following strategy to anyone who would like to do the same:

In looking for publicity for Visual DataFlex and other associated products, I use this resource to locate a suitable article site:

Manhattan Service is a SEO optimization help site, but specifically a inner link especially for articles:

which lists [at the bottom] a number of article sites which accept free articles.

Now, from experience, I recommend 2 sites from this list:




The compelling reasons I recommend these two sites are:

[1] Will my article be formatted nicely and not cluttered with advertisements on key words within my article?
[2] Will the page rank [power to make the article stand out on google] be high enough to effectively publicize my work?
[3] Are the site underwriting standards tough enough to eliminate spam articles so that my article will not be cluttered by junk articles, AND will it stand a chance of being distributed to other article sites?
[4] Will they review and approve my article in a reasonable time frame?

Sites to avoid:
ISnare - this site effectively only publicizes when you pay and your articles will just hang in limbo until you do.

Secondary Site:
Article Factory - this site has low underwiting standards and your post will disappear in time if not popular, however they feed other channels and my article on Visual DataFlex product review got over 600 views, 21 other sites picked up the article, and it is still up and running.

Note: If you have a blog, and feature articles about Visual DataFlex in the blog, I recommend you visit www.BlogUpper.Com [a child site of Manhattan Service] for assistance there.

If you have a topic to write about, and would like to further the cause of Visual DataFlex, please consider publishing an article or more thru these channels!

Peter A Donovan

Monday, September 17, 2007

RoloFlex 12.4 Released Today

RoloFlex 12.4 Released:

RoloFlex 12.4 was released today as a small upgrade to RoloFlex 12.3 which features finishing work to isolate 2 small bugs and add 4 small features.

Features Added:
  • Print List Of RoloFlex Entries
  • Print Envelope
  • Active Toolbar with more choices and data aware highlighting courtesy Peter Brooks [Australia] based on work by Vincent Oorsprong [Netherlands].
  • Color (or colour if you prefer) added to notes courtesy Nat St. Pierre [Canada].

Bugs Fixed:

  • [export all and re-import all did not function properly in all cases]

  • [print lead card was not programmed]

In addition, RoloFlex has been featured in some web articles, and is starting to be offered by some free software download sites:

and featured alongside the release of Visual DataFlex personal edition:

Thanks to all who contributed to this revision,

Peter and Kimberly Donovan

Monday, September 10, 2007

Rewrite: VDF or VB? VDF Advantages

Visual DataFlex Advantages

Ref: Should I rewrite my system in VB or VDF?

Visual DataFlex (VDF)

VDF’s main advantage is speed of development. On a system that deals with large quantities of data, VB will probably require twice the coding time.

One example of this is in error handling. In VB error handling must be coded by hand.

Another example of “out of the box advantages” is the find messages of VDF. Coding “find first or last” is completely supported and coded by VDF into augmentable methods available at both the object and datadictionary class levels.

Overview: VDF is designed for data awareness in a completely scripted environment while VB is not designed as a data aware out of the box solution.

Second, VDF is completely in harmony with your current code base and data.

A conversion of DOS DataFlex to VDF can take your tried and true code and move it mostly intact into an OOPS VDF system dependably without reinventing the wheel.

A conversion of DOS DataFlex to VDF also has the advantage of being run simultaneously with DOS. You can phase the system in gradually instead of being an all out conversion. You can even use the same data tables as DOS until the conversion is complete, and then switch over to client-server when VDF passes validation and takes over the complete role from DOS.

VDF is a great front end for many databases: DataFlex, Pervasive, MySQL, DB2, Oracle, and MS SQL Server for example. The same program code will work, no matter what database you choose (or switch to).

VDF has a 30-year history as a development language designed for working with data. VB has data capability as an add-on. The first 2 versions of VB weren’t even database aware!

VDF has a light footprint. Complex systems can run tolerably well on 5+ year old computers. requires “power-user” type computers for all users to get reasonable performance.

VDF is truly Object Oriented. This type of programming makes development faster, cleaner, & more easily changed down the road. VB is “Object Based” – a partway implementation of the OOPs concept. One part of OOPs is “Classes”. These allow flexible extension of the controls that are used to display data.

· For example, suppose you want to color all fields that are indexed (& therefore can be used for finding). Add the code for doing this into the class, recompile & now every instance of every field that is indexed will be colored. In VB, this change could take weeks – finding every control & adding the code to it.
· Another major advantage to this process is centralized coding. If, for instance, you wanted to change the color assigned to the indexed fields VDF can do this by changing one centralized spot, giving both great power to your code, and also making month-to-month maintenance chores a snap rather than a huge conversion job.

VDF has Data Dictionaries. DD’s are arguably the most powerful part of VDF. All business rules & much of the custom code go here.

· The advantage? As a very basic example, say you always want the Customer Name capitalized. Set this in the Customer DD. From then on, every view, dialog, etc. that uses the Customer DD will always capitalize the Customer Name.

· Two years later, you decide to allow lower case. Go to the DD, change it there & then recompile the application. Every place that uses the Customer Name (doesn’t matter if it’s 1 place or 100) will now allow lower case.

VDF’s Interconnected Data Dictionary Rule Base:

In a VDF application, the database table rules are coded [as above] with basic and advanced business rules. Example: The customer table has a globally applied rule that says the customer can’t go over their credit limit. When you combine the customer DD along with the sales order and lineitem DD, this is what you get:

Sales Order


Now, when saving a new lineitem, the save operation cascades upwards to the customer table and any attempt to save a lineitem that puts them over the credit limit is denied!

VDF has interface features that make it far easier for the user:

Lookups: These are popup lists that (at the click of a button or press of a key) are set up to make finding easy. For example, to look up an order, you might show Order #, Date, Customer, Ship To, Total & Status. The user can really see what they need to do their job efficiently.

Indexing: Put the cursor in the Order # field & you can move back & forth through the table in Order # order. Put it in Order Date & you can browse by Order Date, etc. – no programming required (except creating the indices).

The VDF interface is designed for data entry:

The standard VDF application is MDI (Multiple Document Interface). This allows the user to have 2, 3 or more views of data open at a time, but the whole application can be minimized at one click of a button. It also puts menus and toolbars at the top of the application so they don’t have to be added to each view.

If your users prefer to navigate from field to field with the Enter key (instead of Tab) – add one line of code, recompile & you’re done.

Every action that you can do with a mouse, you can also do with a key or key combination. This means faster & easier entry for skilled users, while allowing the use of the mouse by users who prefer it.

VDF has backward & forward compatibility. An application written in version 9.1 will compile & run in 12.0 (5 versions later) with little or no changes to the code.

VDF pioneered teaming Windows applications with Web applications. A VDF WebApp can easily work with the same data (including the data dictionaries!) that your Windows system uses.

-End Presentation-

Your article, "Visual DataFlex Vs Visual Basic - Visual DataFlex Advantages" - has been accepted and added to the directory:
You've also earned Expert Author status:

Subclassing SL in Visual DataFlex

Hi, while others would think it strange to hear, I have just programmed my first global variable ever and am happy with my decision! As many know, Applause Software is a North American Mfg's rep for Soft Sys which is currently negotiating a VDF 12.1 release of it's proven VDF7 verticle market product named "MASS" (Membership Administration Software Solution). This work is for that project. Much of the code design involves making all instances of a GUI standardized and centralized in coding technique.

Ref: Peter Brooks @ SoftSys: Info@MembershipAdmin.Com

In keeping with my best oops foundation, I have never ever coded a global variable until now. I always used client area properties to communicate between views etc.

The premise:
How to program a selection list or popup dialog to say whether the user pressed OK or not.

Many decisions, especially in views and reportviews need to know if the user changed the value in the dbform or form. Usage of onchange needs to be programmed into each and every dbform or form if this is desired, getting the value prior to forward sending prompt and getting the value after forward sending prompt. Very messy that way.

My global variable is necessary because:
It's programmed into the classes which will be precompiled prior to the client area existing.
Since it's a SL value, each and every dbmodal panel would have to be non-deferred-create if the panel carried the property.

Explanation of this:
Procedure Prompt
Boolean bOk
Set pbOk of (prompt_object(self)) to false // doesn't exist yet! // error!
Forward Send Prompt
Get pbOk of (prompt_object(self)) to bOk // dialog has been destroyed // error!

The gv: // [global variable]

Boolean gbOK
Contained in the TOP of the custom classes use package.
This way, if the classes are used in another program, you don't have to code the gv again.
My classes for Soft Sys based on the dbModalPanel: (special subclass for selection lists).

Class cSoftSysDbModalPanel is a dbModalPanel
Procedure Construct_Object
Forward Send Construct_Object
// Define new Properties:
Property Boolean pbSelectionList Public False
// Create child objects:
// Set property values:

Procedure End_Construct_Object
Forward Send End_Construct_Object
// Add your code that needs to be executed at the end of the object construction here:
// This overrides the individual object settings as existed in VDF7
If (not(pbSelectionList(Self))) Set Border_Style to Border_Dialog
Else Set Border_Style to Border_Thick
// Create and augment procedures and functions
Procedure Popup
Move False to gbOk
Forward Send Popup
Procedure Set Label String sMyLabel
// intercepts the setting of the label, and does a language [australian to usa] translation!
Integer iPos1 iPos2
If (sMyLabel > "") Begin
If (CurrentCountry(Self) = "United States") Begin
POS "Enrol" in sMyLabel to iPOS1
POS "Enroll" in sMyLabel to iPOS2
If (iPOS1 <> iPOS2) Replace "Enrol" in sMyLabel With "Enroll"
POS "enrol" in sMyLabel to iPOS1
POS "enroll" in sMyLabel to iPOS2
If (iPOS1 <> iPOS2) Replace "enrol" in sMyLabel With "Enroll"
Forward Set Label to sMyLabel
// Automatic Save_Header for dbgrids etc. built into dbView-dbModalPanel.
Function DoSaveHeader Returns Boolean
Send Request_Save_No_Clear
If (Should_Save(Server(Self))) Function_Return True
If (IsNullRowID(CurrentRowID(Server(Self)))) Begin
Error DFErr_Operator "Please Enter Info In Top Part Of Entry Form"
If (Err) Function_Return True
Function_Return False
// Note: See individual topic in previous post for this function!
// Note: with search and replace, I replaced the class of all SL panels with this one:
Class cSoftSysDbModalPanelSL is a cSoftSysdbModalPanel
Procedure Construct_Object
Forward Send Construct_Object
// Define new Properties:
// Create child objects:
// Set property values:
Set pbSelectionList to True
Procedure End_Construct_Object
Forward Send End_Construct_Object
// Add your code that needs to be executed at the end of the object construction here:
// Create and augment procedures and functions
// Note: with search and replace, I replaced all instances of dbLists with this class:
Class cSoftSysDbList is a dbList
Procedure Construct_Object
Forward Send Construct_Object
// Define new Properties:
// Create child objects:
// Set property values:
Send DoDefineShadowedColorUpgradeProperties

Import_Class_Protocol cSoftSysShadowedColorUpgrade

Procedure End_Construct_Object
Forward Send End_Construct_Object
// Add your code that needs to be executed at the end of the object construction here:
// These setting OVERRIDE the object settings whatever they may be!
// Makes previously coded stuff all uniform now.
Set CurrentRowColor to clYellow
Set GridLine_Mode to Grid_Visible_Both
Set peAnchors to anAll
Procedure Set Header_Label Integer iColumn String sText
// Another interception of setting the label for a language translation...
If System.Label_Surname gt "" Replace "Surname" in sText with (Trim(System.Label_Surname))
Else If (CurrentCountry(Self) = "United States") Replace "Surname" in sText with "Last Name:"
Forward Set Header_Label item iColumn to sText
// Create and augment procedures and functions
Procedure Ok
If (Move_Value_Out_State(Self)) Move True to gbOk
Forward Send Ok

So now, in effect, what I am doing with the global variable is setting it to false on popup and setting it to true upon clicking the OK button of the SL or pressing enter to select a record in the SL.

Because it's a global variable, it can be coded into the classes which are precompiled prior to the client area (on the desktop) and referred to in class code prior to the oApplication being executed to open the workspace etc.

End Result in Code: // if you need to know whether the user is getting a variable from the SL:

Object oMyForm is a cSoftSysForm // non data aware such as in a report.
Procedure Prompt
Forward Send Prompt
If (gbOk) Begin
// do whatever you need to do with the value like setting a property to govern the constraints or output options.

End Article!

Sunday, September 09, 2007

SaveHeader Function: an upgrade

SaveHeader Function

Upgrade Suggested for your dbgrid's saveheader call to allow entry in them:

// DAW coded save_header function.

Function Save_Header Returns Integer
Boolean bHasRec bChanged
Handle hoSrvr

Get Server to hoSrvr // The Header DDO.
Get HasRecord of hoSrvr to bHasRec // Do we have a record?
Get Should_Save to bChanged // Are there any current changes?

// If there is no record and no changes we have an error.
If ( not(bHasRec) and not(bChanged) ) Begin // no rec
Error DfErr_Operator 'You must First Create & Save Main Order Header'
Function_Return 1

// Attempt to Save the current Record
// request_save_no_clear does a save without clearing.
Send Request_Save_No_Clear

// The save succeeded if there are now no changes, and we
// have a saved record. Should_save tells us if we've got changes.
// We must check the data-sets hasRecord property to see if
// we have a record. If it is not, we had no save.
Get Should_Save to bChanged // is a save still needed
Get HasRecord of hoSrvr to bHasRec // current record of the DD
// if no record or changes still exist, return an error code of 1
If ( not(bHasRec) or (bChanged)) ;
Function_Return 1
End_Function // Save_Header

// Suggested replacement for same:

Function SaveHeader Returns Boolean
Send Request_Save_No_Clear
If (Should_Save(Server(Self))) Function_Return True
If (IsNullRowID(CurrentRowID(Server(Self)))) Begin
Error DFErr_Operator "Please First Enter Info in the Order Header"
If (Err) Function_Return True
Function_Return False
// Notes:
// Save Requests never save blank records so it's safe to call at any time
// We don't give an error when changes exist because the errors already have run
// We only give an error if no info was entered at all in the header
// Ref: Garret Mott's whitepaper "Software as a conversation" we say please.
// This function returns a true value for ANY error not just the one that we send.
// We always return a value in a function whether implied or not.

The second function is both less verbose and superior in both coding technique and performance to the code many software engineers have copied intact from the sample examples.

In addition, it can be dropped almost intact into a dbview subclass!

Note: Garret Mott's "Software as a conversation" can be found in the whitepaper section on and the author can be reached at

The author, Peter Donovan, can be found at

Selection List Upgrade #1

Selection List Programming in Visual DataFlex

Programming a selection [lookup] list in VDF12 can be enhanced with the use of an “enter new” button that allows you to enter a new parent record, and have it “fall thru” the selection list into the data entry program or report.

The selection list has been made such an amazingly easy task by Data Access Worldwide, where a lookup (as pictured below) can be created in just a few clicks and keystrokes.

The Selection List [stock] from the Order Entry Sample Example VDF 12.1 …

The second SL pictured is a great candidate for the addition of an “add new” button.
End result desired pictured here:

… and the add new dialog:

What follows is;

[1] The code from the Modal Dialog
[2] The code from the Selection List

(In VDF 12.1 code)

// dbModalPanel = Popup Dialog for entering new sales person

Use DFClient.pkg
Use SalesP.DD
Use Customer.DD
Use OrderHea.DD
Use DFEntry.pkg

Object SalepAddNewDialog is a dbModalPanel

Property Boolean pbOK
Property RowID priRowID

Object oSalesp_DD is a Salesp_DataDictionary

Set Main_DD to oSalesp_DD
Set Server to oSalesp_DD

Set Label to "Add or Edit Sales Person"
Set Size to 83 308
Set Location to 2 2
Set Border_Style to Border_Dialog
Set Auto_Clear_DEO_State to False // no clear on save

Procedure Popup
Set pbOk to False
Send Clear of oSalesp_DD
Forward Send Popup

Object oSalesP_ID is a dbForm
Entry_Item SalesP.ID
Set Location to 9 91
Set Size to 13 42
Set Label to "Sales Person ID:"

Object oSalesP_Name is a dbForm
Entry_Item SalesP.Name
Set Location to 23 91
Set Size to 13 156
Set Label to "Sales Person Name:"
Set Label_Col_Offset to 2
Set Label_Justification_Mode to JMode_Right

Object oOK_btn is a Button
Set Label to C_$OK
Set Location to 44 185
Set Default_State to True

Procedure OnClick
Handle hServer
RowID riRowID
Move oSalesp_DD to hServer
Send Request_Save
If (Should_Save(hServer)) Procedure_Return
If (not(Current_Record(hServer))) Begin
Send Info_Box "Please Find Or Enter A New Sales Person ~ Then Click Ok"
Get CurrentRowID of hServer to riRowID
Set priRowID to riRowID
Set pbOK to True
Send Close_Panel


Object oCancel_btn is a Button
Set Label to C_$Cancel
Set Location to 44 243

Procedure OnClick
Send Close_Panel


On_Key Key_Alt+Key_O Send KeyAction of oOk_btn
On_Key Key_Alt+Key_C Send KeyAction of oCancel_btn


// Selection List augmented only for the add new button:

Use DFClient.pkg
Use DFSelLst.pkg
Use Windows.pkg

Use SalesP.DD
Use SalepAddNewDialog.dg

CD_Popup_Object SalesP_sl is a dbModalPanel

Set Minimize_Icon to False
Set Label to "Sales People List"
Set Size to 118 265
Set Location to 4 5
Set piMinSize to 97 174

Object SalesP_DD is a SalesP_DataDictionary
End_Object // Salesp_DD

Set Main_DD to SalesP_DD
Set Server to SalesP_DD

Object oSelList is a dbList
Set Main_File to SalesP.File_Number
Set Ordering to 1
Set Size to 71 248
Set Location to 6 6
Set peAnchors to anAll
Set pbHeaderTogglesDirection to True

Entry_Item SalesP.ID
Entry_Item SalesP.Name

Set Form_Width 0 to 40
Set Header_Label 0 to "ID"

Set Form_Width 1 to 200
Set Header_Label 1 to "Sales Person Name"

End_Object // oSelList

Object oOK_bn is a Button
Set Label to "&Ok"
Set Location to 81 97
Set peAnchors to anBottomRight
Set Default_State to True

Procedure OnClick
Send OK To oSelList

End_Object // oOK_bn

Object oCancel_bn is a Button
Set Label to "&Cancel"
Set Location to 81 151
Set peAnchors to anBottomRight

Procedure OnClick
Send Cancel To oSelList

End_Object // oCancel_bn

Object oSearch_bn is a Button
Set Label to "&Search..."
Set Location to 81 205
Set peAnchors to anBottomRight

Procedure OnClick
Send Search To oSelList

End_Object // oSearch_bn

Object oAddNew_bn is a Button
Set Label to "&Add New"
Set Location to 81 8
Set peAnchors to anBottom

Procedure OnClick
Handle hModalDialog
Move (SalepAddNewDialog(Self)) to hModalDialog
Send Popup of hModalDialog
If (pbOk(hModalDialog)) Begin
Send FindByRowID of (Server(Self)) Salesp.File_Number (priRowID(hModalDialog))
Send Display of oSelList
Send Ok of oSelList


On_Key Key_Alt+Key_A Send KeyAction of oAddNew_bn
On_Key Key_Alt+Key_O Send KeyAction of oOk_bn
On_Key Key_Alt+Key_C Send KeyAction of oCancel_bn
On_Key Key_Alt+Key_S Send KeyAction of oSearch_bn

CD_End_Object // SalesP_sl


End Result of Code:

The code above results in a “drop-thru” of the new Sales Person entered and puts their ID/intials in the data entry view without stopping at the selection list.
Peter A Donovan
Applause Software
September, 2007

Wednesday, August 29, 2007

The Theory Of Meaningless Numbers

The Theory Of Meaningless Numbers (TMN0001)
Applause Software
Peter A Donovan

What is a meaningless number?
Meaningless numbers are ID and CODE columns which uniquely identify a record in a database table. They were made up by computer programmers, and in traditional programming, they formed the first entry window where you were responsible for remembering that “D” means Doctor, and “402” is your best customer. Since it would be wrong to discriminate against an entry window just because it’s a letter and not a number [age of equality] I’ll include meaningless letter combo’s in this theory also.

The point?
Users should not be required to remember “402” for General Electric of Massachusetts and “791” for General Electric Turbine Division”, but programmers should indeed still make use of them as the basis of relationships between database table records. Just don’t expect the users to enter or remember them: the truly meaningless numbers and codes can be totally hidden from users and as a study, I will refer to RoloFlex by Applause Software as a good example where each table is based on a unique meaningless number. [reference: : free RoloFlex]

What is a meaningful number?
A meaningful number is those database records that are referred to commonly by number such as PO #4067, Sales Order #1, and Speeding Ticket #352-4635A. These numbers exist on paper and are the primary way of referring to a record of this type. When you go to look up my speeding ticket, you might indeed look it up under my name also, but when a payment is received [good luck] you want to be able to enter the printed number 352-4635A and quickly locate and apply payment before my check bounces.

Can a meaningful and meaningless number co-exist?
Yes. Numeric meaningless numbers are the foundation of unique identifiers of each record, and a meaningful number can co-exist as [both] uniquely indexed [findable] columns in the same data table.

There’s a space here while the programmers hold their heads.

Let’s say you are a database programmer and know that numbers rather than a string which varies in length [throwing off the sort order completely] should be the foundation of the database record [for speed and relationship purposes only], you can program your unique (meaningless) ID column of speeding tickets, and also have a unique (meaningful) column which is ascii [mixed numbers and letters] which is used for finding it.

Why not make the key column a automatic increment number for relation purposes alongside a humanly enterable column consisting of alpha-numeric characters? Hands please? How many programmers have written 200 lines of code to auto-increment “#352-4635A”? The role of the meaningless number is to get auto-incremented in 1 line of code, being totally hidden from the user, and the foundation of the relationship to it’s parent database table. The role of the Speeding Ticket number is to humanly find a record more easily than 12342345345565.

Table Layout Proposed:

Column: Element: Type: Length: Index: Relates To:
1 ID Numeric 16.0 1 (unique)
2 TicketNo Ascii 20 2 (unique)
3 VIN_ID Numeric 10.0 3 VIN.ID // Not VIN (Ascii Field)
4 SSN_ID Numeric 10.0 4 SSN.ID // Not SSN (Ascii Field)

Column: Element: Type: Length: Index: Relates To:
1 ID Numeric 10.0 1 (unique)
2 VIN Ascii 20 2 (unique)

Column: Element: Type: Length: Index: Relates To:
1 ID Numeric 10.0 1 (unique)
2 SSN Ascii 11 2 (unique)

This structure makes use of meaningless numbers and meaningful numbers side by side, each fulfilling their job.

Hopefully there is a programmer slapping his/her head here like the V-8 commercial.

The ROLE of a meaningless number:
Let’s face it. Meaningless numbers are here to stay. Everybody’s got one, but programmers are still stuck on what to do with them. HIDE THEM! In a relational database model, where the child is related to it’s parent by the ID, the value will automatically drop down to the child upon a successful save, making display of this number absolutely unnecessary. I should point out that many good programming firms are based on “Intelligent Design” such as Auto-Mate Software of the USA Please visit this site to read about the story about “Enter the field matrix number”…. It’s a great story.

Let’s go a step further and call a byte a byte. Whether it’s a field matrix number or a part number, due concern needs to be put into the design of a “key field” lookup to determine whether or not it’s meaningful or meaningless. On a part number, why not both? To programmers, here’s my argument: why not use this technique so that if the part number is mis-entered, or changes, you can simply reenter the part number without altering the relationship? Madness or magnificent? It’s your opinion that counts.

Let’s take an example in RoloFlex 12.3 from Applause Software (open source and freeware). The database tables all have a unique ID that is 10 digit numeric: Please refer to the running program and you will see that none are visible. In addition, I have coded the key fields as “noenter” so that if they were made visible, they could not be used! Ten digit ID numbers for everything? Meaningless or Madness?

Hands again? Each programmer who has had to increase a user’s key ID field from 6 to 8 to accommodate 20 years of data entry please stand up! I’ll bet there are a good many among us. Let’s also note in passing that dates on computers are stored as 6 digit integers, and in the western world we are almost out of numbers in the six digit length! Why have we not expanded our dates to 8 or 10 digits? I guess we’ll have to wait until “Y6K” to find out!

The design of meaningless numbers in action:
Let’s take on a RDBMS [relational database management system] example and specifically look at parent and child table design. My first point should be obvious to most programmers, that a parent ID field is used to uniquely identify the parent but (being meaningless) is not displayed to the user at all. In RoloFlex, please note that the parent database tables of the main table have a unique ID which drops down into the main table upon a save, forming the relationship without being seen.

Please note (when inspecting the inner table def's for RoloFlex tables) that the Key ID column has a noenter attribute, meaning that the user cannot change or type in a new value to that column should it appear on the screen. It is auto-incremented from the system file “sysfile” and is totally meaningless to even the database designer other than being a unique value. No surprises here, but let’s look at a child table to see the same technique:

So, what’s the surprise here? On many occasions, I have noticed the lack of a single unique key field on child records. For example, the child of order header would have a key combination of HeaderID and Linenumber. If I applied the same consideration to the CallHist table, then there would be a combo of RolodexID and Call Date as the first index. What [the used] this technique does is to form the basis of a future child table to CallHist. From the get-go, a strong ID field exists to form a potential one-to-one column relationship to a child of CallHist which may exist in the future. The point, then, is to always program an ID column as a unique meaningless number for every table and index it accordingly. Then, progress onwards to specifying all the other columns of the database table.

As an extra bonus, you will see that “recnum” or record number is not defined in any of the indexes making a move from any one back end to another manufacturer’s back end a relatively easy job.

Whitepaper Summary:
I believe I have defined the difference between a meaningful number and a meaningless number and stated that meaningless numbers have no place in data entry! On the other hand, the argument for placing a meaningless number as the foundation of your relationships overwhelms the reasons that you might have for designing a meaningful number as the relationship key: It is my contention that an alphanumeric or string column has no place as the relationship key, and lastly that each table should have an ID field for forming the relationship which totally frees you to change the secondary key column with data entry without compromising the relationships.

Let end users see meaningful numbers only, but put your foundation on “meaningless design” with [hidden] data architecture!

Buzzle Web Portal

Sunday, June 24, 2007

Modern Sales Theory Explained: The Funnel Theory

Author: Peter A Donovan of Applause Software.

The Funnel Theory:

First: The Funnel:

The Funnel is a way of describing your prospect base that is used by ACT and GOLDMINE as their basic premise. The problem with both of these 2 most popular packages in my opinion is that they include so many extra functions in order to sell their product that the basic intent of their system gets lost by users with little or no training and even by veteran users.

Imagine a funnel, like a megaphone with a large open side on one end and a small open side on the other.

Many businesses find themselves in business for 30 years and the sales department has information on about only 20% of the potential market due to turnover, record keeping on paper (unusable in many cases because of being outdated), and general policy of not understanding the funnel theory.

The premise:
The large side represents how many potential accounts you know about in order to be able to contact them and sell your services to.
The small side represents prospects who are ready to make a yes/no decision on a quote or proposal or bid you make and a percentage of these will fall through the small end and become sales.

4 Goals:

1. Increase the funnel by marketing, cold calling, meetings, conventions, inbound phone calls, etc. Premise: The more in the funnel, the more fall thru as sales.
2. Increase the number of prospects at the small rim of the funnel, thereby (making the assumption that your closing ratio stays the same) you get more sales.
3. Skew the funnel with leads that are more likely to be sold. This is done by accessing your funnel lead base and marketing (cold call/direct mail, etc) to a proven segment of the market with a higher closing ratio, or customers where you have an add-on product for what they use.
4. By whatever means including skewing the funnel and teaching modern sales tactics to the field reps, you increase your closing ratio.

6 Assumptions:

1. The more leads in the funnel brings more opportunity to sell your product. If you don't have a way of regularly contacting the entire funnel this assumption is meaningless. Therefore you must generate advertising directed individually at each funnel listing via phone and mail and email.
2. The more information you gather about each funnel lead brings you closer to a sale. You can't sell an account unless you know the name of the decision maker or beginning contact person. You can't determine the value of the account to you without knowing what size the account is, what potential they have to be a client, or information that would make them non-desirable as a customer. If you don't have this information, and a way of using it to select segments of your prospects for contact it's useless.
3. The more frequency of calls to your best market segment leads to higher sales volume. You must have information to fuel this market segment and identify it.
4. Price is meaningless in many cases. You must present yourself to situations where you are the only bidder or have identified the needs of the customer properly and prove both in speaking to the prospect and backup in print that their needs will be best addressed by your company. If you don't save this information for future use [assuming no sale] you put yourself back in time having to do this all over again and lose the ability to skew the funnel based on the information you gather.
5. You must have a way of reporting the funnel. You must have a list of prospects considering a quote ready to make a decision. You must have a list of each field rep's active accounts that they are pursuing. You must have a way (mail merge, email blast) of regularly putting your name in front of the target market based on the info collected.
6. From #5 you must have a way of determining if the inner funnel leads are sold or lost or postponed. This gives you a closing ratio which is the heart of the funnel. To explain, you must log a history that a quote was given, and have a history of which of these resulted in sales (otherwise you can't compute a closing ratio) after the fact. Monitoring activity of leads (the number active), the prospects on the inner edge with quotes, and keeping track of field rep closing ratios over time gives you a pulse.

2 Rules.
1. If a field rep produces many sales you can't touch them and they can do anything they want until the sales stop flowing. To keep this salesrep on top of the heap you must provide them with incoming leads of a high quality which they will only pursue a percentage of due to their status.
2. Longevity and Burnout. The longer you keep the top salesreps as employees, the closing ratio will increase and sales will increase, and it will become easier to project budget and rely on your projections. The supply of quality leads to these reps is the key to keeping them longer.

Your goals as business director is to make everyone understand the funnel theory as explained above and make the:
FUNNEL, the HEART, and the KEY in your sights and produce the needed reports, mailings, etc. to make it happen. You must skew the funnel to do this and keep your eyes on the pulse.

Peter A Donovan

Applause Software
Wakefield, MA USA
(781) 968-5240

Saturday, April 14, 2007

Upgrade For Free ROLOFLEX Published Today

In a previously announced release, a fully featured contact manager and personal information center named RoloFLEX written in Visual DataFlex by Applause Software was upgraded to include the following features:


Please see for downloading the free RoloFlex.

New Features Include:

1. An active toolbar that has these features:
* Shadows the find keys when not in an indexed field.
* Shadows the delete key if a record is not found.
* Shadows the save keys if no changes exist to be saved.
* Puts the DELETE button WAY AWAY from the SAVE button.
* Offers A Save and Clear, or a Save and No Clear. etc.

Thank you to Vincent Oorsprong of DAW Netherlands and Peter Brooks of
Soft Sys/Australia (www.MembershipAdmin.Com) for the ActiveToolbar.

2. VDFQuery is part of the file structure now (The 2.4 beta)
* You can compile now right away without having to path to VDFQuery.

Thanks dearly to Sture Anderson of DAW Netherlands for sharing VDFQuery.

3. VDFSORT Included.
* International Downloaders not in USA English must reindex prior to using.
* This tool is now included without having to use database builder.

There have been over 1000 visits to the download page of RoloFLEX and if you
haven't tried it yet please give it a shot as it is well constructed and highlyuseful.

Thanks to all who visited my website in the process.

Peter A Donovan
Applause (TM) Software
Wakefield, MA USA


1. Install Personal Version Of VDF12.0 (Link On My WebPage)
2. Install RoloFLEX 12
3. Install Updgrade1

Hope you enjoy.

Note: this fully featured RoloFLEX is totally free and includes source code (open source)
and is based on a free personal edition of Visual DataFlex studio by D.A.W.
(Data Access Worldwide of Miami USA)

Note: If you find this RoloFLEX useful for BUSINESS NEEDS there are 2 comments I would
like to make:

1. A runtime license (extremely inexpensive) is required for business use. I would be happy
to quote you pricing on this license.
2. Customization: If you would like RoloFLEX muscled up for your specific business needs
please contact Peter Donovan of Applause Software for a quotation on such.

All the elements mentioned above are freeware with no expiration date for personal usage and to get accustomed to ~the best kept secret~ in the Database Visual Studio industry.

Friday, March 16, 2007

Trademark Turnaround!

[Title:] Trademark Turnaround

Concerning the trademark of Sonata Software LTD previously posted by Peter A Donovan was an article concerning a trademark owned by Sonata Software LTD which could be construed as criticizing Sonata Software LTD for enforcing such.
This is an apology letter to Sonata Software LTD concerning same.


Points Of Apology::
Since I posted my article about Sonata Software LTD enforcing their trademark on the word Sonata in conjunction with developing and marketing business software I have come to realize that;

1. They have every right to enforce their trademark since I had references to my former business under a similar name on the web describing me as performing the same functions as the trademark held by Sonata Software LTD..

2. If Sonata Software LTD did NOT enforce their trademark they could set a precedent which could negate their trademark and damage the company’s investment.

* Now, my business (renamed) is in the same shoes as Sonata Software LTD (Applause TM Software) where I am "composing" this letter to say that I must now also enforce my trademark in the same manner as Sonata Software LTD on the word "Applause" in conjunction with developing and marketing business software and creation of dynamic content web sites.

In my dealings with the Attorney for Sonata Software LTD I have been treated with patience and they have taken the time to explain our mutual dilemna and their position as described above with courtesy and professionalism and I now regret any aspersions I have cast against this company in my previous post in my journal news story and blog.

Where I went wrong!:
I began my DataFlex software business license in 1991 from Data Access Worldwide under the name of Sonata Software without checking if a similar business existed under the same name. For me, the term "Sonata" was a personal term for "moonlighting" since the Moonlight Sonata is my favorite musical composition by Ludwig Van Beethoven, Sonata #14. The sonata is the third most common form of classical musical venue after the symphony and the concerto.

I am hereby giving up all claims to the company name "Sonata Software" and moving on to Applause Software, operating the same business began in 1991 under a new name.

I am also moving the ownership of 2 previously operated sites "SonataSoftware.US" and "SonataSoftware.Biz" to Sonata Software LTD as part of our settlement agreement which meets my approval since I do not operate either anymore.

Former Clients Of Peter A Donovan:
Please find me now at http://www.ApplauseSoftware.Com (781) 968-5240 Still in the same location.

Applause TM Software: A Visual DataFlex Consultancy:
Nothing except my new business name Applause TM Software (I am learning) has changed except the name transition, and Applause Software is the hoped for end result of my efforts for each client!

My Trademark Applause.:
Applause designates my business of developing and marketing custom software for business needs and for developing (currently Electos from the maker of Visual DataFlex) dynamic content publishing websites.

DataFlex began in the days of CPM when "I-CODE" and when DOS began, DataFlex was in the forefront of options and was chosen by a great many companies for it's "FLEX" ability and the English language syntax which is easy to learn similar to COBOL.

My Toolset: Visual DataFlex:
VDF, or Visual DataFlex is the PC (Vista/Windows) version of DOS DataFlex which has been successfully migrated to a world class development studio for database and web to database applications in a RAD (rapid application development) environment especially and specifically suited to database programs.

Backends and FrontEnds:
A "backend" is the database operating environment behind the screen where the data is saved. Visual DataFlex is a "transparent front end", creating programs that can run on most major "backends" such as DataFlex itself, Express SQL, My SQL, IBM DB2, Pervasive, etc.

Sonata Software LTD Clients and Prospective Clients:
If any person reading this review is seeking to contact Sonata Software LTD please do so at www.SonataSoftware.Com.

Intentions: In any future dealings with other companies named "Applause" involved in the same business as my trademark, I intend to extend the same professionalism and courtesy that Sonata Software LTD has shown me.

Sunday, January 07, 2007

NEW: Free Database Development Studio

Just Released From Data Access Worldwide Of Miami.

Freeware database application development studio with no restrictions other than for personal use.

Visual What? has been our bane of existance because we utilize a world class development tool that isn't known by most developers. A Personal Edition of "VDF" is released is so that you can discover the power and rapid development abilities of this system which includes a PC/windows program creator, (WebApp) a web application extention (interface your data with the web), and (Electos) a dynamic content publishing website creator.

"Our most valuable asset is the easiest to market free", a quote by the CEO of Data Access Corp.

Here's the scoop: Visit my website for BOTH a free copy of Visual DataFlex AND a free personal rolodex application which shows the abilities of this tool. I personally am adding both a freeware application which anyone can use for personal reasons (see site for pic) and an offer for a discounted business version once you've decided that this system is desireable for business use.

Data Access is following the example of many other vendors such as MS SQL which now offers a free 25 user "Express SQL" with many of the development features removed from the product. NOT SO with the Personal Copy of Visual DataFlex: you get everything with the agreement that only personal use is allowed.

So, therefore, I offer this personal application which lets you auto-dial, email, save pictures of your contacts, save contact history, report on callback dates, and easily filter your entries by source of entry or category of entry plus letter writing options etc. It's a powerful application for real world personal use so that you can see the power of "VDF". There is also a link to video instruction in VDF where over an hour of presentation on concepts as applied to Visual DataFlex coding may be obtained from Sonata Software.US See: http://www.ApplauseSoftware.Com

The hope of Data Access is that the "geeks" out there (me being one) will download, play, and discover how great this system really is, and how easy it is to develop a rapid application deployment system whether it's PC based software, web data integration, or website CRM publishing.

It is my personal hope that my contribution will lead to new "VDF" developers in the near future. We have a camaraderie amongst "VDF" developers where we share code and help solve others problems and have a number of Newsgroups for help and support, plus a huge online help directory for personal research on the spot.

So, why not take a double freeware offer: the entire development system of a 4GL language which contains sample examples on how to implement usage, and a freeware personal example that you can use immediately with no cost or expiration date?

Quoting from the "Blues Brothers" movie: "It's 106 miles to Chicago, we got a full tank of gas, half a pack of cigarettes, it's dark and we're wearing sunglasses: HIT IT!"

Looking forward to seeing your name on the VDF newsgroup, sincerely Peter A Donovan.