CATIA V4 and V5 - What Does the Difference Mean?
By John M. Switlik, Boeing

We can use vFo and vFi to represent and to study the major paradigmatic thrusts that have occurred in the computational era; that is, we have pre-vFo, vFo, vFi, and the future. The use of vFo and vFi is not meant to refer to CATIA strictly; rather, the article discusses the industry as a whole as it has ExPerienced major transformations.

This article continues the discussion started in the June 2003 COE Newsletter and, like the former, uses three major categories important to the subject (CoT, ExP, and CyB). These are used mainly to support discussion. CoT includes the sum total of CAD/CAM/CAE/etc. capability plus the human side as it currently exists. The expertise that drives a system ("Top Gun") is an integral part of the CoT equation. The KBE view introduces two components, ExP and CyB.

• ExP denotes the expertise as encapsulated in a domain expert that is more than that of the "Top Gun" expertise. ExP includes an incredibly large set of talents and knowledge.
• CyB is the computational collection that can demonstrate expertise bordering on intelligent behavior. CyB in the long run will be mostly computational. An open issue is how large a role the ExP will play. That is, KBE success alludes to the power of a technique that establishes a synergistic coupling of the ExP and CoT realms.

Background
One way to look at the computer in a modern day setting, such as for modeling of geometry or knowledge, is to consider the important issues related to representation (structure), methods (operations), and quality (measurement). This article discusses differences (vFo and vFi) through time (historical perspective) from an external view of the CoT systems that is related to the user's perspective.

The viewpoint is heavily influenced by KBE and by experience with the main programmatic interface (API, vFo - CATGEO and vFi - Automation API). The API is an extension of the "Top Gun" expertise; the idea is to think about the language/environment that will allow full realization of what the ExP can bring to the world via CoT (KBE, and CyB) systems. There is a lot of ground to cover, but this article mostly looks at where we are. The next article will address how choices may play out in the future.

KBE in the vFo era used a system external to CoT that did have the flavor of some of the things that we'll see in the vFi era. The drive to embed KBE capability into CoT will lead to some interesting configurations that need to be better understood.

One facet of the vFi era will be user management of knowledge and that will require languages (full sense of expression) and environments (how the expression gets realized). Along with computational changes, there have been progressive differences, also, in the ExP and CyB components. A large source of the differences relates to the phenomenal growth in prowess that the industry has experienced both in terms of hardware and software. Every discipline now incorporates computational aspects to some extent and, in some cases, to a very large extent, making issues of human/machine interplay of extreme importance.

Representation
Representation is at the core of any computational paradigm, and we can observe changes by eras. Examples abound: structure differences range from simple linear configurations to highly intertwined collections of non-trivial objects; myriad languages and environments for effecting what the computer is supposed to do; the influence that the computer model has on the basis for the knowledge of a domain (ExP adaptation).

Early computational approaches were procedural in scope (the computer was thought to be a large calculator). It was possible that a desk process could map well to being translated to the computer (example, engineering's need for analysis and numeric processing [of a manual sort] had already laid the groundwork for doing steps and cycles in order to process large algebraic systems down to the necessary representation for decision). Back then, resources, such as RAM, disk memory, and interface capability, were limiting. Figuring out how to overcome the constraints influenced some of the properties of representation. Too, the computer was really no more of a partner than was a slide rule (discovery then was oriented toward laying down the foundations, so to speak).

As these resource issues were resolved through time, more advanced methods emerged. By the time of vFo, the industry had larger memory, faster processing, and better software to work with. Not only were systems capable of multi-tasking, the user interface capability allowed direct interaction with the visible analog of the implicit model. The procedural approach was predominating in the vFo era (the 'recipe' view of the world has its place, as does the calculator metaphor). Due to resource limitations, the experience with computation in the vFo era was much more limited than what is currently available.

In the transition period from vFo to vFi, many things happened. Some of these were the following.

• The industry had made progress in architectures.
• The computer became a ubiquitous element.
• The computational metaphor became established.
• There was much more success in modeling some ExP thinking.
• Artificial intelligence techniques had been demonstrated; and so forth.

Improvements came from other avenues (notions of modeling complex objects, of inference by calculation, of browsers on objects, of communication between highly complex objects) and enhanced KBE as it unfolded its potential in the vFo era. We now had bigger implicit models mapping to more extensive portions of the world of the ExP.

Changes built upon various implementations of the abstract data type (ADT) allowed the object (OO) paradigm to emerge. ADT allows structure and information hiding. OO added further enhancements to the ADT relating to inheritance (a very familiar subject in the ExP world) and to polymorphism (allowing operators to apply to several types of things - a good example of the latter would be the "+" operator which has different meanings depending upon the context [integer, real, complex, etc.] yet the operator has the same look to the user).

Structure using OO can map better to the ExP view, almost as a natural association. One truism is that domain expertise as embedded in ExP/CoT is both difficult (deep understanding) and complicated (breadth and depth). Newer methods can manage complication by information hiding through various forms of abstraction (pushing information to a lower level). Difficulty is harder to manage; we have seen the object-oriented community wrestling with this issue.

There are very powerful forms of information hiding. An example of this is a translation of a major collection of geometry. The model knows the related components, gets them transformed in space, and does all this without the CoT user having any concern about the details (a tremendous amount of bookkeeping best kept invisible to the user). That is, unless there is a failure. At certain points, such as debugging, encapsulation has to be opened. It is precisely in those times when covers need to be opened that we ought to measure difficulty (quality issue of internal versus boundary views).

In the implementation of ExP knowledge, the details of computer specifics may not map easily to something the ExP understands. A computational model can be full of widgets that are arbitrary abstractions that somehow need to explain themselves. One KBE form was illustrative in this sense of allowing the ExP to express knowledge, albeit in a very difficult language that was remote from the CoT experience. Despite the shortcomings, the KBE supported phenomenal success. We can only guess what a tighter coupling with CoT will bring with the emerging capabilities available in the vFi era.

Many of the new methods are machine-supported, such as modeling with graphical expressions (using Unified Modeling Language - UML). Hopefully, the new mixtures will more strongly link ExP knowledge to executable states (either CoT or CyB). Representation in the vFi era ought to be seen as a multi-faceted affair that encompasses structure, behavior, roles, ontology, and many other properties. The computer can become a partner (due to the richness inherent in the newer paradigms available to vFi, discovery will take on a whole new meanings).

There are other improved mappings between the CoT and ExP worlds. Simulation is a very good example and will become more prevalent (for instance, early cycle quality assessment). The highly capable mathematical packages are another example; these have multiple characteristics but symbolic processing is very important (allows integration of closed form solutions with numeric processing - thereby improving insight). The newer paradigms afford better interfaces between CoT and ExP such that visualization support can be a form of explanation; they offer CyB many new ways to improve.

All in all, there may be many differences between the vFo and vFi paradigms, but there are also common threads that will be important to progress. That we have both the vFo and vFi environments available ought to allow a framework to improve our understanding of the computational metaphor (subject of the next article). One example is the evolution in expectations that differ by era. In the former eras where there were not many easy mappings between the computer and the reality, hence the ExP world was expected to adapt to the computer. What we are seeing is co-evolution of the computer, its use, and its user. With the advent of all the capability of the vFi era, the computer will be able to adapt to the ExP world through adjustable structures and improved methods.

Methods
Like representation, methods have both similarities and differences over the eras. As an example, abstraction did exist in the vFo era; the process of taking ExP thoughts of a problem to solutions on the computer is an example. The vFi flavor of abstraction is much richer leading to more elaborate implicitness.

Operations in the vFo era were on lower-level objects. Even with simple abstractions, this low-level view was far removed, many times, from the ExP view. An exception would be where desk procedures directly mapped to the computational work. Some numeric processes had this characteristic (not much different than the partitioning of problems to allow manual calculation). In this type of computing, one benefit that we did have within the vFo realm was that a tight (somewhat) map between a manual and an automated computation was possible.

Operations in the vFi era are on higher-level objects. In vFi, abstractions build layer upon layer (with many levels). One metaphor has been the floor, where above the floor is the external view of what is hidden below the floor. The layering can be thought of as recursive or even stacked (whether the results are like a house of bricks or of cards are an issue of quality). Given that there is a gap between the CoT/CyB and ExP views, mappings are more tenuous. Even when there are analogues between the views, the framework of information hiding makes many computational aspects less accessible to direct observation, thereby necessitating computational truth handling (such as, belief and modal logics, veracity checking, and so forth).

The OO discipline means to ensure a proper basis for applications (example, sanctity of the independence of modules during encapsulation). That is, the best of worlds would allow errorless plug and play of computational modules. The optimal OO practices would provide modules that never leak or misbehave and would pay attention to issues of trust.

From the knowledge viewpoint we need to think of how the ExP world maps to the computer model. Associations between ExP and CoT/CyB will be multifaceted and non-trivial. For some types of ExP domains, a vFi language/environment might have a close correspondence to how the ExP world thinks. In terms of CoT the language/environment would include the "Top Gun" interface as well as the API. In other domains, there may not be so close a tie; these issues will be played out in the vFi era. No matter the perceived perfection on the newer computational paradigms, there will be leakage in the ExP/CoT/CyB mappings (on the computational side, the industry will need to address limits; on the human side, conceptual-level blips can occur anywhere in the aggregation of knowledge).

One control approach is to have a very small user interface over a very large black box. One might say that the ExP is supposed to give over control to a CoT/CyB of immense intelligence. This option works when the casual users have access to trustworthy expertise (via a CoT/CyB). Another option is a very large user interface over a very large black box. This is the option for allowing a tight (and powerful) interplay between a human and system-based expert; it leads to associations between ExP and CoT/CyB that are many-to-many. Some KBE systems have demonstrated the potential for this type of partnership. With the vFi realm, there is the potential for the computational model to meet the intuition of the ExP by handling higher-level objects.

By its very nature, the later day computation is abstract and complex at its core. There are fewer computational constraints, yet these cannot be totally ignored due to issues of complexity (quality issue of turnaround expectations). As we have seen within KBE, it is very easy for a manageable set of instructions to become outside of time bounds. In some KBE, the strategic use of the ExP (human in the loop) helped provide for successful implementation of these systems. For instance, a lot of benefit can be derived from attaining only an incomplete state by computer that is closed by ExP action (some large percentage of the requirement having been met with automation thereby producing savings).

With improvements via representation that allows abstraction, methods need to be smart in terms of handling undecidability and explanation. Both of these can be managed and will look a lot different as we move forward with the vFi realm. Undecidability will be addressed more fully in the next article. explanation can use visualization in the sense of a "picture being worth a thousand words." But, a question deals with looking at boundary versus core information; information hiding can lead to misinformation (next article). Even the existence of probes that penetrate a cover can be problematic. As was mentioned in the prior article, the openness of code does not necessitate understanding.

Quality
Quality, in the broad sense, subsumes measurement and judgment, concerning activities related to the economics of ExP/CoT/CyB interplays. The advent and progressive evolution of the computational metaphor has brought to fore many interesting problems with which to wrestle. Computational actions of the vFi era can be difficult (undirected firings across both deep and broad structure, not necessarily local) and complicated (uncoordinated expansions along very intricate 'causal' chains, possibly at disparate sites). We need to remember that 'distributed' approaches are non-deterministic at the core; KBE examples abound that show how 'vertigo' is an appropriate metaphor for complicated computation (in many senses, see next article).

Tracing computation states has always been problematic. In the early days (prior to vFo), reviewing memory dumps was unavoidable; these were presented in a machine code or similar format. One improvement allowed output that was more suitable for human consumption. In the vFi era, machine code analysis is augmented with source level mappings.

Desk checking of computational fragments by hand was possible in the vFo days due to the less implicit mappings. Nowadays, with growing implicitness, we really need to have computers checking themselves and other computers. One open issue deals with real factors from the world of the ExP that need to be added to put a solid foundation under the correspondences of ExP/CoT/CyB. When there are physical consequences of a computational chain, quality can be more easily assessed. We have seen progress in such measurements for effect, such as for fit, form, and function. From tying computation to real world consequences, we learn a lot about control.

These lessons must somehow carry over to the more abstract world. In areas where the computational consequences are for the most part only of a 'virtual' nature, measurement can be problematic. One approach would be to ensure that the computer model 'knows' about physics, etc. This quality issue can be managed somewhat by process in a quasi-empirical fashion.

Another issue deals with performance expectations. The shortest execution path may still be of concern though the modern attitude is that we can always throw hardware at a problem. The fact remains that complexity properties of seemingly simple routines can border on being 'undoable' (beyond space and time bounds). Lessons learned through the eras about using approximations will still be apropos.

One way to look at it is to consider milestones (ExP constraints imposed on the computer). If a computationally influenced decision is needed in a matter of hours, then computations that take weeks are of no use. Through time, lead-time planning has helped. But, consider when a CyB has to meet strict decisional milestones and can only supply incomplete data. Even the use of fuzzy techniques does not entirely remove the need for the ExP talents at resolving conflicts in situations like this.

In many instances, decisions might have to be made with the best assumptions that are known at the time, which can be problematic when those assumptions are not understood due to their computation basis (where a lot of the causal information might be hidden). ExP may have to take unnecessary risk if the CyB element does not provide proper support prior to the decision. We usually expect human judgment to cope with the difficult and complicated; that assumes understanding, which can be problematic when a lot of the pertinent knowledge is provided by a black box (possibly, known only by its behaviors).

Another characteristic of layered abstractions is that issues of performance can be harder to resolve in the vFi era. Quality is influenced by structure; not only is the internal (hidden) aspect important to quality, how pieces relate will be of concern. Though a performance requirement can be (ought to be) imposed on a module, it is not the case that a mixture of components must add up in a linear fashion. Non-linear characteristics result from both the difficult (in terms of undecidability) and the complicated (in terms of potential for exponential growth).

Even with the better use of the interface for visualization, evaluation of CoT/CyB results by the ExP can be problematic. Given a trained eye, 'looks good' might be an appropriate evaluation. An example would be surface curvature displays being used to evaluate smoothness, albeit in a subjective manner. Even having quantitatively expressed quality criteria can be problematic. It is possible that too much boundary information that looks good can cover underlying internal problems.

One can see evidence of modern approaches that reduce criteria down to appearances. In a sense, the computational metaphor may reinforce this, since OO and other abstractions can deal mainly with boundary conditions. Many times we need to go beyond the boundary, to the core. Clarifying this dynamic will be imperative to KBE success. In terms of one view, 'walking and quacking like a duck' might be sufficient for deducing 'this is a duck' in a situation, yet wouldn't we want in some cases to take the determination to the DNA analysis level? Applying situational evaluation to support properly informed judgment has a major role in interplay of the ExP and the CyB realms. The evolution of CoT will be central to this progress.

Conclusion
There have been tremendous differences experienced in the evolution from early computing through the vFo and the vFi eras. The current computational frameworks are both powerful and problematic; the power will result in many applications heretofore not possible; the problems are both new and old and will be worthy of continued discussion.

Given the CoT/ExP/CyB differences between the vFo and the vFi eras, one wonders if there are threads that continue through time. The next article will look at issues related to vFi as it applies to either the legacy situation or to the green field. An argument will be made that knowledge is like nature (continuous, discrete, temporal, etc.). Subsequent eras may very well depend upon former eras. Knowledge can have longevity, with some nuggets being long term (are there gems are embedded in the languages of the former eras?).

For further discussion of the content of this article, please e-mail the author.

About the author
John M. Switlik is an Associate Technical Fellow (Boeing, Commercial Airplane, Wichita Define Systems, KBS, john.m.switlik@boeing.com). His interests cover a broad spectrum: computational support for applied science, mathematics, and management; lifecycle and veracity control for system, application, and domain engineering; integration, use, and quality of computational knowledge.

Definitions:
vFo - The former computational era that excelled despite serious constraints on resources.
vFi - The current/future computational era that might learn a few lessons from vFo in terms of trades about resources.
KBE - Knowledge Based Engineering, http://www.ktiworld.com/pdf/understanding-tis-2.pdf
CoT - CAD/CAM/CAE/etc. plus "Top Gun" talents. This element does not subsume CyB.
ExP - expertise as encapsulated in a domain ExPert includes an incredibly large set of talents the nature of which we do not fully understand but upon which the sustained success of CyB may very well depend. We will find ourselves increasingly trying to negotiate between the ExP and the CyB views of the world.
CyB - Hardware, software, control, and KBE that can demonstrate expertise bordering on intelligent behavior. CyB with ExP governance provided the early KBE successes. Autonomous CyB can be a worthy goal, with the appropriate caveats. In the meantime, there is a whole set of benefits waiting for proper CoT/ExP/CyB configurations.