WO2000063773A1

WO2000063773A1 - Adaptable component architecture

Info

Publication number: WO2000063773A1
Application number: PCT/US2000/010251
Authority: WO
Inventors: Ralph Garvin, Jr.; John Finkelstein
Original assignee: Woosh! Inc.
Priority date: 1999-04-16
Filing date: 2000-04-14
Publication date: 2000-10-26
Also published as: AU4354000A

Abstract

A method for producing a software program provides a software development platform that includes an engine and a plurality of software objects form a network of software components. Knowledge about a software application is decomposed into components. The components are then generalized and stored in the network.

Description

ADAPTABLE COMPONENT ARCHITECTURE

Field of the Invention

This invention relates generally to application development, and more specifically to WEB- site development.

Background of the Invention

In the past, two paradigms have been used. One is a functional paradigm where functions are called over and over again to perform various operations in a program. There was a shift to object-oriented paradigm where you associate objects or data with methods which allow operations on the data. Data and then operations that are performed on the data and then put together are called an object. A user would then send messages to this object and the object would perform certain tasks for the messages it was ready to perform. The objects were put in classes and hierarchies were created that represented larger applications so that a user could manually modify the objects, connect them together with messages and have them perform various tasks. This is a fairly technical process. Co-generators can take a given set of parameters and write out code automatically to perform a certain task, but it can only write code out in a very limited way based on certain parameters that the user inputs.

In addition, there are template-based approaches with code snippets that have blanks. The user can fill in the blanks and produce a code.

A major deficiency with the paradigm approach is that there is limited amount of leverage; once the user invests time in developing one class, a fair amount of time is still required in order to customize that class to perform additional functions- When a class is instantiated, which means creating an object from an existing class, a fair amount of work is still required on the part of the user. Another drawback to the paradigm approach is that once an object has been created and instantiated, developing them to work together requires a substantial investment in time on the part of the user, and the result is still extremely error prone and difficult to do. Therefore, the cost of creating these applications is very high and requires a very large technical skills set in order to make it work. Then the knowledge is basically lost because those things are unique and customized for a very specific purpose. Because it is more complex, it takes a longer amount of time for a user to create these linkages through messages and the like.

SUMMARY

An object of the present invention is to provide a software development platform that stores application knowledge in a reuseable manner.

Another object of the present invention is to provide a software development platform that can create a large number of software applications.

Yet another object of the present invention is to provide a software development platform that generates a sofeware application, record specifications of the components used to create the software application which can be used to maintain the application and generate different applications.

Another object of the present invention is to provide a software development platform that creates records of components used to create software applications, and where the recorded components can be aggregated to create other software applications.

A further object of the present invention is to provide a method of developing software applications for a large number of software applications.

Still another object of the present invention is to provide a method of developing software applications and record specifications of the components used to create the software applications which can be used to maintain the application and generate different applications- Another object of the present invention is to provide a method of developing software applications that creates records of components used to create software applications, and where the recorded components can be aggregated to create other software applications-

These and other objects of the present invention are achieved in a software development platform that includes an engine. Also included is a plurality of software objects, each software object having more than one capability.

In another embodiment of the present invention, a method for producing a software program. A software development platform is provided that includes an engine and a plurality of software objects form a network of software components. Knowledge about a software application is decomposed into components. The components are then generalized and stored in the network.

BRIEF DESCRIPTION OF THE DRAWINGS

Figure 1 is a schematic diagram of an ADO database useful with the present invention.

Figure 2(a) is a schematic diagram of a network of communications useful with the present invention.

Figure 2(b) is a flow diagram illustrating the flow of behaviors and capabilities in the Figure 2(a) network.

Figure 3 is a flow diagram illustrating set theory of the present invention.

Figure 4(a) is a flow chart illustrating a large number of ADO's with unique behavior are put together and combined together. Figure 4(b) illustrates the creation of genre applications.

Figure 5 illustrates an assimilation process of the present invention.

Figure 6 is a flow chart illustrating the achievement of platform independence of the present invention-

Figure 7 is a flow chart illustrating component isolation of the present invention.

DETAIL DESCRIPTION OF THE PREFERRED EMBODIMENTS

The present invention solves the above deficiencies by providing a system that requires very little manual intervention to get very, very different specific results by storing in the system the knowledge required to build a wide variety of applications without a great deal of manual intervention.

One embodiment of the present invention is a software development platform with an engine. A plurality of software objects are also included. Each software object has more than one capability. Each software object can have more than one dynamic capability, be capable of dynamically interacting with the other software objects and be an adaptable object. The plurality of software objects form a network of software components. The network combines the objects to produce interactive software applications. The objects combine dynamically based on a program specification to produce interactive computer applications. Each object can have an unfixed number of capabilities that are in general categories. Suitable general categories include but are not limited to a quick sort, a bubble sort, a list box display, a display of an order entry screen, a display of a product list, a communication protocal, an http object request and a remote program call. The network forms a combinatoric explosion of software application types- Software programs generated by the present invention can be monitored and rewirteen by modifying the program specification without rewritting the software code itself.

In another embodiment, the present invention is a method for producing a software program. A software development platform that includes an engine and a plurality of software objects form a network of software components is provided. Knowledge about a software application is decomposed into components. The components are generalized and stored the in the network. The method can also include, specifying broad associations between the components, introducing a program specification into the engine, the engine reading the application network and generating a software application, determing if an errror occurs in the software application, localizing an error to a specific software component, changing the software component that generates the error, and generating a software application without the error. With the method of the present invention, the software application can be in communication with the network and monitored. New capabilities can be into the network to create new relationships generate a new software application with new features.

Referring to Figure 1 , a database ADO is shown which connects to two or more website ADOs: web 1 and web 2. Website 1 has a database 1, annd Website 2 has a different database. Additional Wedsites also have different databases- Separate instantiations of a class are created and given specific parameters in order to read from one database or another. The database object reads from any database so once the website queries the object it interfaces with the correct database object and vice versa. The database object adapts to virtually any schema or design of a database without instantiation, and the database object is self-instantiating or manual modification; it adapts to the different schemas so that the database object only needs to be created once, and then a wider amount of webs can attach to it.

In Figure 2(a) an ADO is indicated as a circle. Also included are 6 lines showing the communication as well as the different spaces- Each ADO has a set of inherited behaviors that it receives from parent space and propagated behaviors that it sends to child space. Each ADO receives capabilities from child space and sends them to parent space. Targets are also indicated and include items including but not limtied to database schema and visuals.

Each ADO object resides in a network of connections, forming what is called a directed acyclic graph or DAG. Figure 2(a) shows the two components of the DAG, the child's space portion of the graph and the parent's space portion of the graph. Another area shown is the target space. The target space defines the range of behaviors that the ADO can have. One or more edges from the parent space send a behavior to the ADO which then allows it to select a specific instantiation from target space. Once the ADO recognizes an inherited behavior the ADO then knows how to instantiate itself- The ADO also notes how to send more information down to additional ADOs below it. Once a behavior is recognized, this behavior causes an instantiation to occur with the ADO, and the ADO adapts for each inherited behavior. The ADO propagates down the new set of behavior. Once the propagation is complete, it returns back up the ADO chain. The ADO's instantiation or adaptation is then complete. Then it sends that adaptation back up the chain. This is a recursive process where all the nodes in the graph instantiate themselves, adapt and send behavior throughout the graph. The behavior can be inherited from the parent space- It will use that inherited behavior to instantiate itself in some way, then it will propagate additional behaviors down.

As shown in Figure 2(a), each propagated inherent behavior is instantiated and sends additional messages down. This is like a waterfall approach of increasing knowledge when it reflects back. Propagation is similar to a wave. When propagation gets to the bottom of the graph, at the bottom of the child space, all the behavior propagates back up.

Referring to Figure 2(b), behaviors propagate down, and capabilities are returned to the parent throughout the whole graph. Behaviors propagate down the chain, capabilities are acquired and sent back up the chain, and at the top of the chain, a complete application is generated More specifically, an important element of the propagation starts at the top of the parent space At a high level, starting at the top of the parent space, a user can specify at a very high level of abstractionwhat is desired, for example, an auto parts site, or a spreadsheet application of any type

Referring to Figure 3, a Set A is identified, where A is a behavior A propagates down to a new node identified as node 2 and goes into the target space to obtain a whole set of additional behaviors identified as behaviors B^A and C^Λ As the set of behaviors is propagated down, more specificity is created as it goes deeper into the graph because the target space and the links contain the knowledge of how to create an application For example, if a list box is desired, it knows that it is linked directly to certain elements in target space that are appropriate for list boxes, including the number of elements in the list box, where to obtain the information required to populate the list box and how to behave when clicked This information is retained in target space

Normally a user would have to use a list box class, then write methods about a list box, parameters that the list box takes and messages that the list box responds to and then wire it up to the rest of the application The present invention provides one list box item that is already fully wired It knows everything it needs in target space Once a user tells it what kind of list box is desired, which is what behavior A does, where A=the type of list box needed, it knows exactly what to get from target space to instantiate itself and make a specific list box that is desired Examples include a shopping basket for an auto parts site, or an Excel spreadsheet so that when clicked on shows the user the whole formula These are all varied instantiations of the same object No wiring is needed because the object comes pre-wired and it knows how to instantiate itself based on the inherited behavior

Additionally, from the top level, a user can specify a different behavior B, and that same list box will get different things from the target space and be a totally different list box.

In Figure 3, set theory is depicted. For example, behavior B is

BA BA propagated to two different objects. That propagation yields D and E which are additional sets of behavior for those items generated from behavior B^A

Referring to Figure 4(a), a large number of ADOs that have unique behavior are put together when a user starts out with a set of ADOs, Set 1, and combined together to produce a certain number of applications. If an EDI-type capability is desired, a user can add an EDI ADO, and all of the applications generated can be EDI-capable immediately. Additionally, all applications previously generated can immediately be regenerated with this capability. As the size of the network grows, the amount of time to create any given application falls off exponentially. Initially, the cost is higher to produce the first application, since all ADOs must be created from scratch. Once ADOs are created and wired together, the second and subsequent applications take less time and the amount of time to create an entire set of applications decreases dramatically.

Applications that are similar take less time to create. These are called same genre applications (Figure 4(b)). If applications are created of the same genre, the amount of time taken to support the application decreases. A new genre with little in common with previous applications will taken more time until the basic functionality is in place. As soon as the application shares a common feature with other applications, as most do after the initial development of ADO's, the amount of work and time required decreases exponentially because additional ADOs are not required- Adding a connection is all that is required to obtain varying or new behavior that propagates down and a complete new application is formed. When additional ADOs are added, whether unique and modular or similar, there is an exponential increase in the number of sites that can be created- Some of those sites may not make sense to generate links but the capability is available. The present invention provides that by increasing the 5 network, the ability to match a wider range of needs vary easily without a huge investment in additional development costs.

Figure 5 shows assimilation. Assimilation is the process in which adaptable component architecture extends itself. For example, a number of parent ADOs and parent space is shown using XML based EDI (electronic data interchange) using XML. AlDusers are tied together with XML and connected to be XML capable. Because all of these sites connect to the data, the database ADO can read almost any schema. It can translate that to XML using the XML ADO and a user can perform any type of communication with any outside vendor using XML. Later if the user wishes to retool the sites to a different interchange, for example Java instead of XML, then adding a Java ADO would obtain these new links. This means that a user can specify at the top whether the application should be XML capable, Java capable, or both. In other words, if the user wants the site to be XML capable, it will automatically use the XML ADO. Not only does propagation allow an ADO to instantiate itself, propagation can also redefine the behavioral paths. If something is propagated down, depending upon the t fe of propagation being sent, it will go in a certain direction and use a certain component or group of components, or change and go in a different direction.

The ADOs can change to adapt to a wide range of things. The network itself can reconnect itself based on the behaviors that are propagated down. This provides the ability to rapidly assimilate new technologies. If a new technology appears, it can be added. By simply having certain behaviors, an ADO can aggregate all of these different capabilities and the propagation wave of behaviors goes down while the capabilities rise back up. Through that process, any new capability can be added, or it can assimilate any upcoming capability. The network itself is not limited in terms of what it can hold.

Figure 6 illustrates how platform independence is achieved. First the ADOs and their associated links are created. In Figure 6, the ADOs shown have been categorized into 3 groups: the TLADOs or top level ADOs, the median ADOs, and the atomic ADOs. When the application logic is developed, the atomic ADOs are the only portion of the graph that is tied directly to a specific server platform. This is specifically directed to web implementation- One example is where the atomic ADOs all contain connections to advanced data objects which is specific to Microsoft IIS4 However, if it was desired to move to Tango or some other platform, we can simply swap out this set of atomic ADOs and put in a new set and change from IIS4 to Tango, or IBM's Net Commerce server. Platform independence is maintained and completely new applications can be produced. Because all of the low level functionality of the atomic ADOs are abstracted, this capability of the present invention provides stability to still leverage all this application knowledge that is used to create entire sites. Using this paradigm provides a new way to approach platform independence. All the logic in the application is expressed in the top level ADOs and the median ADOs. This allows only aMnic ADOs to interact with the lowest level component.

Figure 7 illustrates component isolation. In object-oriented systems when an object is instantiated, and methods are written, the objects may message other objects and cause the system to become unstable, because a user does not know how to correctly reference some other parts of the system. In the present invention, the inlθraction between components are maintained in a graph. When a new object is created and the need exists to link the object to target space in order to cause instantiation, it is maintained in the graph itself. This prevents instability and errors. Other systems can be created in order to insure that when an object is created, it knows the valid parameters ahead of time and thus the chance that the object will instantiate it2$f incorrectly lessens. Another aspect is that once all the other components are debugged, if this object fails, it does not cause the other objects to fail. A higher degree of error protection is obtained in this way.

While embodiments of the invention have been illustrated and described, it is not intended that these embodiments illustrate and describe all possible forms of the iifl-Gfention. Rather, the words used in the specification are words of description rather than limitation, and it is understood that various changes may be made without departing from the spirit and scope of the invention. What is claimed is:

Claims

1 A software development platform, comprising

an engine, and

a plurality of software objects, each software object having more than one capability

2 The platform of claim 1, wherein each software object has more than one dynamic capability

3 The platform of claim 1, wherein each software object dynamically interacts with the other software objects

4 The platform of claim 1 , wherein the plurality of software objects form a network of software components

5 The platform of claim 4, wherein each software objects is an adaptable object

6 The platform of claim 4, wherein the network can combine the objects to produce interactive software applications

7 The platform of claim 6, wherein the objects combine dynamically based on a program specification to produce interactive computer applications

8 The platform of claim 1, wherein each object has an unfixed number of capabilities that are in general categories

9 The platform of claim 1 , wherein at least one general category is a quick sort

10 The platform of claim 1 , wherein at least one general category is a bubble sort

1 1. The platform of claim 1 , wherein at least one general category is a list box display.

12. The platform of claim 1, wherein at least one general category is a display of an order entry screen.

13. The platform of claim 1, wherein at least one general category is a display of a product list

14. The platform of claim 1, wherein at least one general category is a communication protocal.

15. The platform of claim 1, wherein at least one general category is an http object request.

16. The platform of claim 1, wherein at least one general category is a remote program call.

17. The platform of claim 4, wherein the network forms a combinatoric explosion of software application types.

18. The platform of claim 4, wherein the programs generated can be monitored and rewirteen by modifying the program specification without rewritting the software code itself.

19. A method for producing a software program, comprising:

providing a software development platform that includes an engine and a plurality of software objects form a network of software components;

decomposing knowledge about a software application into components;

generalizing the components; and

stored the components in the network.

20. The method of claim 19, further comprising:

specifying broad associations between the components.

21. The method of claim 19, further comprising:

introducing a program specification into the engine, the engine reading the application network and generating a software application.

22. The method of claim 21, wherein the software application is in communication with the network and monitored.

23. The method of claim 21 , further comprising:

determing if an errror occurs in the software application

24. The method of claim 23, further comprising:

localizing the error to a specific software component;

changing the software component that generates the error; and

generating a software application without the error.

24. The method of claim 21, further comprising:

introducing new capabilities into the network;

creating new relationships to form; and generating a new software application with new features.