Background:

All objects in the system are defined by their associated class definition. Typically, these are loaded dynamically from a class definition file (a .PVC file). This file contains a declaration of all the object properties, methods, and inheritance options. In addition, the class definition files usually include the code associated with the object methods.

ProvideX normally does the loading of the class definition automatically whenever the first instance of an object is created. During the creation process, if an object's class definition is not known, its class definition file is read and the class structure is created in memory. When this class definition is no longer needed (i.e. when there are no longer any instances of that class in the system), it is removed from the system.

The Problem:

While all of this sounds great and works well, problems often develop when objects are frequently created and destroyed. If an application uses objects in any significant way, the overhead of class structure creation can have a significant impact on system performance.

Take for instance an application where data items are managed by objects. When reading and accessing the data elements, it is quite common to have objects defined for each record accessed. As an application processes the data, each new record may cause the deletion of all instances of a sub-ordinate class requiring fresh reloads of the class structure with each record processed. For example, if invoice detail items are accessed as a collection of objects, changing invoices can cause all instances of the detail object to be deleted resulting in the need to re-create the object class on the next record.

The Solution:

The PxPlus Object Class Cache Manager (OCCM) solves this problem by maintaining copies of previously used class structures in memory. This means that when a new instance of an object is created, it class definition will not have to be read from PVC file. When this feature is enabled, class definition structures and associated program logic are maintained within the system instead of being discarded.

A new system parameter '+J' has been added to the system that controls the number of object classes that will be cached. By default, this is set to ten (10) resulting in the system preserving the last 10 Class definitions no longer in use by the system. Setting this to zero will disable the Class cache mechanism.

What it means to you:

In short, PERFORMANCE. By eliminating the reloading and recreation of class structure information, you will see better performance in your object oriented applications. Actual performance improvement will depend on the design of your application and the number of objects you utilize.

If you are using objects or are considering using objects then the Object Class Cache Manager is something you need to consider.

Object Cache --- A smart reason to switch to PxPlus

OOPS - We did it again

That’s right! We've made a bigger and better OOPS with release v8.01 of PxPlus. Never content to sit on our laurels, we have researched numerous other object oriented programming languages to see what else we could add to PxPlus. As a result, we have come up with a great new capability – dynamic properties.

Not only can objects now dynamically add new properties on the fly internally within the object but this is also allowed from external application code. Up until now, PxPlus objects had static property lists--- that is the list of properties in the object were obtained from the object class definition and could not be altered. Unfortunately, in the real world things change constantly, so why shouldn't our objects? Well, now they can.

Internal Dynamic Property Creation:

To create new properties within an object, PxPlus has added a new directive "ADD PROPERTY". This new directive allows an instance of object to add to its own property list. The directive functions very much like the STATIC directive; however, instead of the properties only being accessible from within the object, the properties are accessible externally.

This new capability allows you to create objects that can take their property list from dynamic information, such as, the file dictionary. For example, you could create a generic file IO object that opens a data file using its internal data dictionary then dynamically adds the files data fields as properties; as in:

On_create:
   Enter File_name$
   Open object (hfn,IOL=*) File_name$
   Static _fileno
   _Fileno = lfo
   Add Property IOL=IOL(_Fileno)
   …

External Dynamic Property Creation:

Taking this one-step farther is PxPlus new ACCEPT PROPERTIES clause on the DEF CLASS directive. When this clause is present, external applications can dynamically create properties within an object simply by assigning them a value. This allows objects to be created to serve as simple storehouses of application data, simplifying the passing and access to an ever-changing list of values.

For example, an object could be created to hold values to pass between programs. By using dynamic properties, the application simply assigns whatever properties it wants to the object then passes the object handle, as in:

0010 DEF CLASS "params" ACCEPT PROPERTIES
0020 END DEF

->a=new("params")
->?a'*

->a'company$="Joes Crabs"
->a'City$="Any town"
->?a'*
CITY$,COMPANY$,
->print a'city$
Any town

To make it easier to determine if a property exists within an object, we have enhanced the MAX and MIN function to allow not only numeric values but also string values. So to test if a property exists, it's simply a matter of issuing MAX(property, ERR=xxxx). If the property does not exist, the error branch will be taken.

These new enhancements increase the flexibility and functionality of OOPS in PxPlus dramatically and once you start using them you'll wonder how you ever lived without them or all the other great features exclusive to PxPlus.

As always, PxPlus has what you want and what you need.

VERSION 8 has arrived

To all our loyal customers, after many delays we are happy to report that Version 8 of PxPlus is now available. Rest assured that this is not a change in our philosophy of providing you with timely version updates. We apologize for these delays but during our QA process, we encountered a critical problem with the initial release of the product. Once we identified and corrected the issue, we worked with Sage to make sure that the fixes were compatible with ProvideX and available to everyone in the community. Unfortunately, this process took longer than we had expected. However, the good news to you and to the ProvideX community as a whole, is that not only are these corrections available in PxPlus but they will also be available in the next interim release of Sage’s ProvideX.

Furthermore, our delay is your gain. In the interim, to compensate our customers we have continued making interim releases to version 7, which would have normally required a v8 upgrade key. Our way of saying thank you for your patience and continued support.

Please Note:
Version 8 is a major release and as such is subject to an upgrade fee.
Customers on our maintenance plan, CCP, are automatically eligible for free updates.
New licenses purchased on or after August 1, 2007, are also entitled to a free upgrade to version 8.
The V8 executable may be used with level 6 or 7 activation keys, but without access to any new features.
For more information on how you can get the latest version, please contact our sales department.