CASE-BASED RETRIEVAL FRAMEWORK

Abstract

In one embodiment, a method includes storing a set of integration cases previously used for adapting a standard enterprise system. The integration cases include a problem description and a problem solution for the adapting of the standard enterprise system. The method receives an integration problem for extending the standard enterprise system. The integration problem has a problem description and not a problem solution. A similarity between the problem description of the integration problem and the problem description of the set of integration cases is determined and one or more similar integration cases from the set of integration cases to the integration problem is determined based on the determined similarity. The method then outputs the one or more similar integrations cases to a user. The problem solution for a similar integration case is usable to determine the problem solution for the integration problem.

Description

BACKGROUND

Particular embodiments generally relate to enterprise systems.

Despite the advances in Service-Oriented Architectures (SOA), the integration of complementary services into standard enterprise systems requires deep expert knowledge. Typically the integration of services, provided by partners or independent software vendors, is carried out in time- and cost intensive integration projects.

In most cases, extension or adaptation of a core enterprise system itself is required. In order to extend or adapt standard enterprise systems a very high level of business domain knowledge as well as technical expert knowledge are required. Therefore services are typically integrated by highly specialized expert consultants (system or service integrators).

System integrators typically start from scratch while integrating services into standard enterprise systems. Given a new integration problem system integrators implicitly and manually search for similar problems they solved in the past, e.g. by searching in code fragments or documentations of already solved integration solutions. This implies a high degree of manual work and therefore leads to high integration costs.

SUMMARY

In one embodiment, a method includes storing a set of integration cases previously used for adapting a standard enterprise system. The integration cases include a problem description and a problem solution for the adapting of the standard enterprise system. The method receives an integration problem for extending the standard enterprise system. The integration problem has a problem description and not a problem solution. A similarity between the problem description of the integration problem and the problem description of the set of integration cases is determined and one or more similar integration cases from the set of integration cases to the integration problem is determined based on the determined similarity. The method then outputs the one or more similar integrations cases to a user. The problem solution for a similar integration case is usable to determine the problem solution for the integration problem.

In one embodiment, the problem description for the integration problem comprises a first set of attributes, the problem descriptions for the set of integration cases comprise a second set of attributes, and the similarity is determined between the first set of attributes and each of the second set of attributes.

In one embodiment, determining the similarity includes computing local similarity measures for an integration goal description, an integration context description, and an integration requirements description.

In one embodiment, the method includes outputting a questionnaire; receiving answers to questions for the integration problem on the questionnaire; and generating the problem description for the integration problem from the answers.

In another embodiment, a non-transitory computer-readable storage medium contains instructions for controlling a computer system to be operable to: store a set of integration cases previously used for adapting a standard enterprise system, wherein integration cases include a problem description and a problem solution for the adapting of the standard enterprise system; receive an integration problem for extending the standard enterprise system, the integration problem having a problem description and not a problem solution; determine a similarity between the problem description of the integration problem and the problem description of the set of integration cases; determine one or more similar integration cases from the set of integration cases to the integration problem based on the determined similarity; and output the one or more similar integrations cases to a user, wherein the problem solution for a similar integration case is usable to determine the problem solution for the integration problem.

In one embodiment, an apparatus includes one or more computer processors and a computer-readable storage medium including instructions for controlling the one or more computer processors to be operable to: store a set of integration cases previously used for adapting a standard enterprise system, wherein integration cases include a problem description and a problem solution for the adapting of the standard enterprise system; receive an integration problem for extending the standard enterprise system, the integration problem having a problem description and not a problem solution; determine a similarity between the problem description of the integration problem and the problem description of the set of integration cases; determine one or more similar integration cases from the set of integration cases to the integration problem based on the determined similarity; and output the one or more similar integrations cases to a user, wherein the problem solution for a similar integration case is usable to determine the'problem solution for the integration problem.

The following detailed description and accompanying drawings provide a better understanding of the nature and advantages of the present invention.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 depicts a system for providing definition and retrieval of integration cases according to one embodiment.

FIG. 2 depicts a case-based reasoning cycle for service integration according to one embodiment.

FIG. 3 shows a more detailed example of case-based recommender system according to one embodiment.

FIG. 4 shows different categories included in an integration case according to one embodiment.

FIG. 5 shows an example of a similarity assessment according to one embodiment.

FIG. 6 a shows an example of integration goal similarity measure according to one embodiment.

FIG. 6 b shows an integration context similarity measure according to one embodiment.

FIG. 6 c shows an example of integration requirements similarity measure according to one embodiment.

FIG. 6 d depicts the global integration case similarity measure according to one embodiment.

FIG. 7 depicts a simplified flowchart for performing case-based retrieval according to one embodiment.

FIG. 8 a shows an interface used by the service integrator to define the integration goal attributes according to one embodiment.

FIG. 8 b shows an interface used by the service integrator to input the integration context definition according to one embodiment.

FIGS. 8 c and 8d depict interfaces that allow the service integrator to input information for the integration requirements attributes according to one embodiment.

FIG. 8 e shows an interface that allows the service integrator to input similarity measures to be used with different attributes according to one embodiment.

FIG. 8 f shows an example of retrieved results according to one embodiment.

FIG. 9 shows a more detailed example of an enterprise system according to one embodiment.

FIG. 10 shows an example of an interface of a business application according to one embodiment.

FIG. 11 illustrates hardware of a special purpose computing machine configured with a case-based retrieval framework according to one embodiment.

DETAILED DESCRIPTION

Described herein are techniques for a case-based retrieval framework. In the following description, for purposes of explanation, numerous examples and specific details are set forth in order to provide a thorough understanding of embodiments of the present invention. Particular embodiments as defined by the claims may include some or all of the features in these examples alone or in combination with other features described below, and may further include modifications and equivalents of the features and concepts described herein.

System Overview

FIG. 1 depicts a system 100 for providing definition and retrieval of integration cases according to one embodiment. A case-based recommender system 102, which includes a case-based retrieval framework 104 and a knowledge base 106. Case-based retrieval framework 104 provides a platform with a knowledge base of already solved integration cases that can be leveraged for adapting a present problem. An integration case is a description of a previous adaptation of the enterprise system that was performed. Case-based retrieval framework 104 retrieves integration cases that are similar to the present problem to allow a service integrator to adapt a problem solution of the already solved integration case as a solution for the present problem. The adaptation of the problem solution allows re-use of previous knowledge to adapt the enterprise system.

In one example, the service integrator inputs a new integration problem that includes a problem description into case-based retrieval framework 104. The integration problem may be considered an integration case also. However, the term integration problem is used for discussion purposes and is an integration cases that does not include a solution. Case-based retrieval framework 104 searches knowledge base 106 to determine integration cases that have been previously solved. Case-based retrieval framework 104 outputs the integration cases based on the similarity to the new integration problem. The service integrator may then use the integration cases, which include a problem description and problem solution to determine the solution for the new integration problem.

In one embodiment, case-based retrieval framework 104 is used when an extension to a standard enterprise system is being performed. A standard enterprise system may be a standard software system, such as an enterprise resource planning (ERP), customer relationship management (CRM), supply chain management (SCM), or supplier relationship management (SRM) system. The standard enterprise system may be sent to a variety of companies. Each company may want to adapt or extend the standard enterprise system. For example, certain customizations may be performed, such as by adding new service integrator interface (UI) elements to core UI components, adding new process steps to core process models or even extending business objects with additional fields.

In one embodiment, the system integrator may want to integrate a complementary service into the standard enterprise system. The integration problem may be described based on different categories that define the problem, such as the categories of an integration goal, an integration context, and integration requirements. Based on the problem description, case-based retrieval framework 104 searches knowledge base 106 for similar integration cases that have already been solved in the past using a case retrieval algorithm. A list of existing integration cases is generated and output to the system integrator. The list contains integration cases that are ranked according to their computed similarity to the integration problem currently. An integration case may be selected and adapted to the integration problem that is trying to be solved.

Case-based Reasoning Cycle

Particular embodiments use case-based reasoning for determining the integration cases. FIG. 2 depicts a case-based reasoning cycle 200 for service integration according to one embodiment. Particular embodiments focus on a define integration goal phase, a define integration context phase, a define integration requirements phase, and a retrieve similar integration cases phase. However, the entire cycle will be described.

At 202, a new integration case is initiated. At 204, an integration goal phase is performed. The integration goal defines the general goal that should be reached by the integration solution. For example, the goal may indicate what kind of target system should be extended, what kind of customizing/flexibility use case should be implemented, or what kind of integration flavor should be implemented (e.g., a service integrator interface or process extension). As will be described below, the integration goal may be defined using a wizard-based questionnaire.

At 206, a define integration context phase is performed. The integration context defines the functional area within the enterprise system where the service should be integrated. For example, the functional area may be core UI or process components that need to be extended to integrate the service. The context may be a service context and/or a target system context. The service context is associated with the provider of the service and describes the context of a service that may be integrated. For example, the service may be provided by an outside provider and/or the enterprise. The service context may define what service should be integrated or what are the business semantics of the service.

The target system context is a consumer context, that is, the context associated with the customized enterprise system. The target system context determines which functional area of the enterprise system the service should be integrated (business semantics) or what components in the enterprise system should be extended (e.g., UI and/or process components). The integration context may be defined using a wizard-based questionnaire as will be described below.

At 208, a define integration requirements phase is performed. The integration requirements may be grouped into different categories that may describe requirements for the integration solution. For example, the categories may be UI extension requirements, process extension requirements, business logic extension requirements, technical integration requirements, and non-functional integration requirements. These integration requirements may be defined using the wizard-based questionnaire and will be described in more detail below.

At 210, a retrieve similar integration cases phase is performed. In this phase, existing integration cases that have problem descriptions that are considered most similar to the problem description of the new integration problem are determined and output. The similarity is computed using a range of different similarity measures. The different types of similarity measures may depend on different attributes defined in the new integration problem. Customization of weights for the different similarity measures may be provided and are described below.

At 212, an adapt integration solution phase is performed. A similar integration case that is output may be selected and re-used as a template to be adapted with respect to the new integration problem. In one embodiment, a problem solution part of a similar case may be extracted and adapted to the new application context of the new integration problem to be solved. The integration solution may be modeled using adaptation patterns that may link patterns to extension points of service elements, add patterns, delete patterns, and replace patterns.

At 214, a revise integration solution phase is performed. In this phase, the adapted or solved new integration case is validated as to whether it meets the integration requirements. The criteria may include the correctness of the solution and quality of the solution.

At 216, a retain integration case phase is performed. After the solved new integration problem has been validated, an integration case with the problem description and the solution is stored in knowledge base 106. This case may be used in future cases to solve other integration problems. For example, case-based retrieval framework 104 may learn by the learning of a new experience (new integration case), learning of similarity knowledge (e.g. weights), or learning of adaptation knowledge.

Integration Case Description

FIG. 3 shows a more detailed example of case-based recommender system 102 according to one embodiment. Case-based retrieval framework 104 includes a case representation meta-model 302 and a case retrieval algorithm 304. Knowledge base 106 also includes different information gleaned from previous integration cases, such as application extensibility models, service models, an adaptation pattern library, similarity measures, a case-base, and a rule base. An adaptation framework 306 is used to adapt the similar integration cases.

Case representation meta-model 302 provides metadata that describes categories for an integration case. For example, FIG. 4 shows different categories included in an integration case 402 according to one embodiment. Broadly, integration case 402 includes an integration problem 406 and an integration solution 408.

Integration problem 406 is a description of the problem for the integration case. For example, a description of the problem may be what extension needs to be performed on the standard enterprise system. Integration problem 406 covers all the information needed to decide if this case is applicable for a new integration problem (query case). In one embodiment, the content includes the goal to be achieved by the integration solution, the context of the problem situation, and requirements/constraints for the integration solution.

Integration solution 408 is the solution for the problem. The solution for the problem may be how to extend the standard enterprise system. Integration solution 408 includes information that describes a solution to the integration problem sufficiently. For example, the information includes the solution itself (e.g., integration models, substantiated adaptation patterns, extended core models, other documentation), possible alternative solutions, feedback/solution evaluation, and justification/explanations.

At 410, the specific categories for integration case 402 are shown. The meta-model includes a problem description 412 (corresponding to integration problem 406) and a problem solution 414 (corresponding to integration solution 408).

Problem description 412 includes different attributes that can be defined for the problem. Although the attributes included in problem description 412 are described, case-based retrieval framework 100 is designed in such a way that it is possible to flexibly add further attributes and similarity measures. The attributes outlined are just examples. The integration goal description includes attributes that may define the enterprise system that should be extended, define the customizing or flexibility use case that should be implemented, or define the principle integration flavor of the service in the target consumption environment of the enterprise system. Different attributes are described in Table 1 in Appendix A.

The integration context description describes the service that should be integrated into the enterprise system and defines the business semantics of the service to be integrated. Also, in an enterprise system context, the business semantics of the target components in the enterprise system that should be extended by the new service, the target UI components of the enterprise system that should be extended/adapted, and the target process components of the enterprise system that should be extended/adapted may be defined. Different attributes for the integration context specification are described in Table 2 of Appendix A.

The integration requirements specification includes different categories of UI extension requirements, process extension requirements, business logic extension requirements, technical integration requirements, and non-functional requirements. UI extension requirements define how an existing UI component of the standard enterprise system should be extended in order to integrate the complementary service (delivered by a third party provider, e.g. ISV).

UI extension requirements are the requirements that define what is needed to extend the UI. UI extension requirements that define a textual description of the integration requirements, how the service should be triggered within a UI component, whether the UI component needs to be extended with additional UI controls, and whether the UI component needs to be extended with additional UI controls to gather information that is required to call the service or show/display result values of the service implication. Table 3 of Appendix A shows different attributes for the UI extension requirements specification.

Process extension requirements define how an existing process component of the standard enterprise system should be extended in order to integrate the complementary service (delivered by a third party provider, e.g. ISV). Process extension requirements may define the initiator of a process extension scenario, a position with respect to a process where the extension process should be plugged in, whether data should flow from a core process to an extension process, whether data should flow from the extension process to the core process, the communication mode between the core process and the extension process, whether multiple core processes are involved in the integration scenario, and whether multiple extension processes are involved in the integration scenario may be defined. Table 4 of Appendix A describes different attributes for process extension requirements.

Business logic extension requirements define how the existing business or application logic of the standard enterprise system should be extended in order to integrate the complementary service (delivered by a third party provider, e.g. ISV). Business logic extension requirements may define different attributes that may be associated with the business logic of an application. For example, the different attributes may define whether data returned from a service should be persistent in the enterprise system, whether the integration logic has to read data from the enterprise system, whether the integration logic has to write data into the enterprise system, whether the integration logic needs to access additional business logic on the enterprise system, whether an interactive service integrator task is required in the integration logic, whether a human service integrator task is required in the integration logic, whether a customizing parameter has to be set/adjusted in the enterprise system, and whether a new customizing parameter has to be added to the enterprise system. Table 5 of Appendix A describes attributes in the business logic extension requirements.

External service integration requirements describe requirements that are used to define how to integrate external services. The attributes define whether standard business-to-business (B2B) protocols should be used for the communication with the external service and which technical communication protocols should be used for the communication with the external service. Table 6 of Appendix A shows different attributes for the external service integration requirements.

Non-functional integration requirements define non-functional constraints that the extension logic defined by the service integrator should fulfill. Non-functional integration requirements define whether the integration logic needs to authenticate in the communication with the external service, whether the communication is performance-critical and if caching mechanisms are required, whether the communication with the external service should be logged, whether the messages sent to the service or received from the service should be encrypted, whether the messages sent to the service or received from the service should be digitally signed, and whether some specific transaction handling is required. Table 7 of Appendix A shows different attributes for non-functional integration requirements.

Case Retrieval

The first three phases of defining the integration goal, defining the integration context, and defining the integration requirements have now been described. The following will describe the retrieve similar integration cases phase. In one example, a case retrieval algorithm uses a similarity assessment based on a local-global principle. The local-global principle computes local similarity measures for attributes and then computes a global similarity measure using the local similarity measures. This process will be described in more detail below.

The similarity assessment computes the similarity between a new integration problem (e.g., query case) and an integration case (e.g., existing case) from knowledge base 106. FIG. 5 shows an example of a similarity assessment according to one embodiment. An integration problem 502 is input into case-based retrieval framework 104. The similarity assessment compares a number of integration cases with the integration problem. For discussion purposes, the integration case is shown as an integration case 504 for the comparison.

Integration problem 502 includes a problem description but no integration solution. Integration case 504 includes a problem description and also an integration solution. The integration problem for the query case includes a number of attributes iq1 . . . iqn that describe the problem. Also, for the existing case, a number of attributes ic1-icn describe the problem for integration case 504. A similarity measure W1 . . . Wn between similar attributes of the problem description is calculated.

Each attribute may be assigned an attribute type. In one embodiment, each attribute of the integration problem is compared to the respective attribute of the integration case retrieved from the knowledge base. The similarity function depends on the attribute type. For each attribute type it might be possible to configure multiple similarity functions. Attributes of different types may also be compared in other embodiments. A single attribute may be compared or a group of attributes may be compared together. For each attribute, a separate similarity function may be used. However, the same similarity function may be used multiple times in comparing different attributes types. First, a local similarity measure is performed on the respective attribute type. A global similarity measure may then be determined by combining the local similarity measures using an amalgamation function (e.g., a weighted average of the local similarity measures).

The following will describe the global similarity measure and then different examples for local similarity measures for the attributes of the problem description. The global similarity measure measures global similarity for the integration problem and an integration case. In one embodiment, the global similarity measure weights and aggregates the different local similarity measure results. Other global similarity measures may also be used. In one example, the global similarity measure may be defined by weighting local similarity measures for the attributes as defined by:

sim                                                                                                                                                                                                                                                                    (                                              iq                        ,                        ic                                            )                                        =                                                                                            ∑                                                      i                            =                            1                                                    n                                                                                                                                                                                                                                w                            i                                                    *                                                                                    sim                              i                                                                                                                  (                                                                                                iq                                  i                                                                ,                                                                  ic                                  i                                                                                            )                                                                                                                                                                            ∑                                                      i                            =                            1                                                    n                                                                                                                                                                                                    w                          i
Explanations
iq             Query case
ic             Integration case
iqi            Attribute i of query case
ici            Attribute i of integration case
simi(iqi, ici) Local similarity measure for case attribute i
wi             Weight of similarity measure for case attribute i
N              Number of case attributes

The following will describe the various local similarity functions. The sample attributes that are described above with respect to FIG. 4 will be used; however, other attributes may also be appreciated and other local similarity measures may be used.

FIG. 6 a shows an example of integration goal similarity measure according to one embodiment. The similarity measure sim_goal is used to compare the attributes for the integration goal description in the integration problem and the integration case. The integration goal similarity measure may be the weighted average of the local similarity measures for the attributes “TargetBusinessSystemType”, “UsageScenario”, and “IntegrationFlavor”. These attributes are described in Table 1 of Appendix A. Attributes described in Appendix A herein are examples and other attributes may be contemplated. The following equation may be used to determine the integration goal similarity measure:

sim                        goal                                                                                          (                                                                              iq                            goal                                                    ,                                                      ic                            goal                                                                          )                                                              =                                                                                                                                                                                                                        w                                  sys                                                                *                                                                                                      sim                                    sys                                                                                                                                          (                                                                                                                  iq                                        sys                                                                            ,                                                                              ic                                        sys                                                                                                              )                                                                                                                              +                                                                                                w                                  uc                                                                *                                                                                                      sim                                    uc                                                                                                                                          (                                                                                                                  iq                                        uc                                                                            ,                                                                              ic                                        uc                                                                                                              )                                                                                                                              +                                                                                                                                                                                                                          w                                flavour                                                            *                              sim                                                                                                                                                                                                                      (                                                                                                      iq                                    flavour                                                                    ,                                                                      ic                                    flavour                                                                                                  )                                                                                                                                                                                                          w                          sys                                                +                                                  w                          uc                                                +                                                  w                          flavour
Explanations
iqgoal                    Goal specification part of the query case
icgoal                    Goal specification part of the integration case
simsys(iqsys, icsys)      Local similarity measure for the case attribute
                          ‘TargetBusinessSystemType’
wsys                      Weight of similarity measure for the case attribute
                          ‘TargetBusinessSystemType’
simuc(iquc, icuc)         Local similarity measure for the case attribute
                          ‘UsageScenario’
wuc                       Weight of similarity measure for the case attribute
                          ‘UsageScenario’
sim(iqflavour, icflavour) Local similarity measure for the case attribute
                          ‘IntegrationFlavor’
wflavour                  Weight of similarity measure for the case attribute
                          ‘IntegrationFlavor’

The above measure computes the local similarity measures for the attributes above, weights them, and aggregates them.

FIG. 6 b shows an integration context similarity measure according to one embodiment. The integration context similarity measure sim_ctx measures similarity for the attribute integration context description. The similarity measure sim_ctx may be defined as the weighted average of the local similarity measures for the external service to be integrated and the core application components of the target system that have/had to be adapted. For example, the local attributes shown in Table 2 of Appendix A may be used. An equation for the integration context similarity may be:

sim                        ctx                                                                                          (                                                                              iq                            ctx                                                    ,                                                      ic                            ctx                                                                          )                                                              =                                                                                                                                                                                                                        w                                  service                                                                *                                                                                                      sim                                    service                                                                                                                                          (                                                                                                                  iq                                        service                                                                            ,                                                                              ic                                        service                                                                                                              )                                                                                                                              +                                                                                                                                                                                                                          w                                                                  core                                  comp                                                                                            *                                                                                                sim                                                                      core                                    comp                                                                                                                                                                    (                                                                                                            iq                                                                              core                                        comp                                                                                                              ,                                                                          ic                                                                              core                                        comp                                                                                                                                              )                                                                                                                                                                                                                                          ?                                                +                                                  ?                                                                                                                                                                                                            ?                                                                                  indicates text missing or illegible when filed
Explanations
iqctx                    Context specification part of the query case
icctx                    Context specification part of the integration case
simservice               Local similarity measure for the service to be
(iqservice, icservice)   integrated
wservice                 Weight of the similarity measure for the service
                         to be integrated
simcorecomp              Local similarity measure for the core application
(iqcorecomp, iccorecomp) components that are extended/adapted
wcorecomp                Weight of the similarity measure for the core
                         application components to be extended/adapted
?                                                                                                                                          ?                                                                                  indicates text missing or illegible when filed

The integration context similarity measure includes a service similarity measure and a core application component similarity measure. The service similarity measure sim_service may be further defined as the weighted average of the local similarity measures for the business semantics and syntactical/technical characteristics of the services to be compared:

sim                        service                                                                                          (                                                                              iq                            service                                                    ,                                                      ic                            service                                                                          )                                                              =                                                                                                                        w                                                          s                              sem                                                                                *                                                                                    sim                                                              s                                sem                                                                                                                                                (                                                                                                iq                                                                      s                                    sem                                                                                                  ,                                                                  ic                                                                      s                                    sem                                                                                                                              )                                                                                                      +                                                                              w                                                          s                              syn                                                                                *                                                                                    sim                                                              s                                syn                                                                                                                                                (                                                                                                iq                                                                      s                                    syn                                                                                                  ,                                                                  ic                                                                      s                                    syn                                                                                                                              )                                                                                                                                                                            w                                                      s                            sem                                                                          +                                                  w                                                      s                            syn
Explanations
iqservice               Query case attribute of the service to be integrated
icservice               Integration case attribute of the service to be integrated
simssem(iqssem, icssem) Local similarity measure that compares the business
                        semantics of the services to be integrated
wssem                   Weight of the similarity measure for the business
                        semantics of the services
simssyn(iqssyn, icssyn) Local similarity measure that compares the
                        syntactical/technical characteristics of the
                        services to be integrated
wssyn                   Weight of the similarity measure for syntactical/
                        technical characteristics of the services

A core application component measure sim_core—comp may be further defined as the weighted average of the local similarity measures for the business semantics and the syntactical/technical characteristics of the core application components to be compared:

?                                        =                                                                  ?                                                                    ?                                                                                                                                                                                    ?                                                                                  indicates text missing or illegible when filed
Explanations
iqcorecomp                       Query case attribute of the
                                 core applications component(s) that
                                 need to be extended/adapted
iccorecomp                       Integration case attribute of
                                 the core applications component(s) that
                                 have been extended/adapted
simccsem                         Local similarity measure that
(iqccsem, icccsem)               compares the business semantics of the
                                 core application component(s)
wccsem                           Weight of the similarity measure
                                 for the business semantics of the
                                 core application components
sim                                              cc                                                  ext                          cap                                                                                                                                (                                                                        iq                                                      cc                                                          ext                              cap                                                                                                      ,                                                  ic                                                      cc                                                          ext                              cap                                                                                                                          ) Local similarity measure that compares  the technical extension capabilities  of the core application component(s)
w                                          cc                                              ext                        cap Weight of the similarity measure  for the technical extension capabilities of the core application component(s)
?                                                                                                                                          ?                                                                                  indicates text missing or illegible when filed

The core application component extensibility capability measure sim_{cc—ext—cap} in the core application component measure may be further defined as the weighted average of local similarity measures for the UI extension capabilities and process extension capabilities:

?                                        =                                                                  ?                                                                    ?                                                                                                                                                                                    ?                                                                                  indicates text missing or illegible when filed
Explanations
iq                                          cc                                              ext                        cap Query case attribute that defines  the technical extension capabilities  of the core application component(s)
ic                                          cc                                              ext                        cap Integration case attribute that defines  the technical extension capabilities  of the core application component(s)
sim                                              cc                                                  ui                          oxt                                                                                                                                (                                                                        iq                                                      cc                                                          ui                              oxt                                                                                                      ,                                                  ic                                                      cc                                                          ui                              oxt                                                                                                                          ) Local similarity measure that  compares the UI extension capabilities  of the core application component(s)
w                                          cc                                              ui                        ext Weight of the similarity  measure for the UI extension  capabilities of the core application component(s)
sim                                              cc                                                  pro                          ext                                                                                                                                (                                                                        iq                                                      cc                                                          pro                              ext                                                                                                      ,                                                  ic                                                      cc                                                          pro                              ext                                                                                                                          ) Local similarity measure that  compares the process extension  capabilities of the core application component(s)
w                                          cc                                              pro                        ext Weight of the similarity measure for the process extension capabilities  of the core application component(s)
?                                                                                                                                          ?                                                                                  indicates text missing or illegible when filed

FIG. 6 c shows an example of integration requirements similarity measure according to one embodiment. The integration requirements similarity measure sim_reqs may be defined as the weighted average of local similarity measures for the UT extension requirements, the process extension requirements, the business logic extension requirements, the technical integration requirements, and the non-functional requirements attributes:

?                                        =                                                                  ?                                                                    ?                                                                                                                                                                                    ?                                                                                  indicates text missing or illegible when filed
Explanations
iqreqs               Requirements specification part of the query case
icreqs               Requirements specification part of the integration case
simui(iqui, icui)    Local similarity measure that compares the UI extension
                     requirements of the cases
wui                  Weight of the similarity measure for UI extension
                     requirements
simp(iqp, icp)       Local similarity measure that compares the process
                     extension requirements of the cases
wp                   Weight of the similarity measure for process extension
                     requirements
simble(iqble, icble) Local similarity measure that compares the business logic
                     extension requirements of the cases
wble                 Weight of the similarity measure for the business logic
                     extension requirements
simti(iqti, icti)    Local similarity measure that compares the technical
                     integration requirements of the cases
wti                  Weight of the similarity measure for the technical
                     integration requirements
simnfr(iqnfr, icnfr) Local similarity measure that compares the non-functional
                     integration requirements of the cases
wnfr                 Weight of the similarity measure for non-functional
                     integration requirements
?                                                                                                                                          ?                                                                                  indicates text missing or illegible when filed

The UI extension requirements measure may be defined as the weighted average of the local similarity measures of the attributes within the UI extension requirements sub-category as shown in Table 3 of Appendix A. The UI extension requirements measure may be defined as:

${\mathrm{sim}}_{\mathrm{ui}}\left({\mathrm{iq}}_{\mathrm{ui}},{\mathrm{ic}}_{\mathrm{ui}}\right)=\frac{\sum _{i=1}^nw_i*{\mathrm{sim}}_i\left({\mathrm{iq}}_{{\mathrm{ui}}_i},{\mathrm{ic}}_{{\mathrm{ui}}_i}\right)}{\sum _{i=1}^nw_i}.$

The process extension requirements measure may be defined as a weighted average of the local similarity measures of the attributes within the process extension requirements sub-category shown in Table 4 of Appendix A. The process extension requirements measure may be defined by:

${\mathrm{sim}}_p\left({\mathrm{iq}}_p,{\mathrm{ic}}_p\right)=\frac{\sum _{1=1}^jw_{p_i}*{\mathrm{sim}}_i\left({\mathrm{iq}}_{p_i},{\mathrm{ic}}_{p_i}\right)}{\sum _{i=1}^jw_{p_i}}.$

The business logic extension requirements measure may be defined as the weighted average of the local similarity measures of the attributes within the business logic extension requirements sub-category shown in Table 5 of Appendix A. The business logic extension requirements measure may be defined as:

${\mathrm{sim}}_{\mathrm{ble}}\left({\mathrm{iq}}_{\mathrm{ble}},{\mathrm{ic}}_{\mathrm{ble}}\right)=\frac{\sum _{i=1}^kw_{{\mathrm{ble}}_i}*{\mathrm{sim}}_i\left({\mathrm{iq}}_{{\mathrm{ble}}_i},{\mathrm{ic}}_{{\mathrm{ble}}_i}\right)}{\sum _{i=1}^kw_{{\mathrm{ble}}_i}}.$

The technical integration requirements measure may be a weighted average of the local similarity measures of the attributes within the technical integration requirements sub-category of Table 6 of Appendix A. This technical integration requirements measure may be defined as:

${\mathrm{sim}}_{\mathrm{ti}}\left({\mathrm{iq}}_{\mathrm{ti}},{\mathrm{ic}}_{\mathrm{ti}}\right)=\frac{\sum _{i=1}^Tw_{{\mathrm{ti}}_i}*{\mathrm{sim}}_i\left({\mathrm{iq}}_{{\mathrm{ti}}_i},{\mathrm{ic}}_{{\mathrm{ti}}_i}\right)}{\sum _{i=1}^Tw_{{\mathrm{ti}}_i}}.$

The non-functional requirements measure may be defined as a weighted average of the local similarity measures of the attributes within the non-functional requirements sub-category shown in Table 7 of Appendix A. The non-functional requirements measure may be defined as:

${\mathrm{sim}}_{\mathrm{nfr}}\left({\mathrm{iq}}_{\mathrm{nfr}},{\mathrm{ic}}_{\mathrm{nfr}}\right)=\frac{\sum _{i=1}^pw_{{\mathrm{nfr}}_i}*{\mathrm{sim}}_i\left({\mathrm{iq}}_{{\mathrm{nfr}}_i},{\mathrm{ic}}_{{\mathrm{nfr}}_i}\right)}{\sum _{i=1}^Pw_{{\mathrm{nfr}}_i}}.$

FIG. 6 d depicts the global integration case similarity measure according to one embodiment. The global integration case similarity measure sim_com may be defined as the weighted average of the local similarity measures for the integration goal, the integration context, and the integration requirements categories:

${\mathrm{sim}}_{\mathrm{com}}\left(\mathrm{iq},\mathrm{ic}\right)=\frac{\begin{array}{c}{w}_{\mathrm{goal}}*{\mathrm{sim}}_{\mathrm{goal}}\left({\mathrm{iq}}_{\mathrm{goal}},{\mathrm{ic}}_{\mathrm{goal}}\right)+w_{\mathrm{ctx}}*{\mathrm{sim}}_{\mathrm{ctx}}\left({\mathrm{iq}}_{\mathrm{ctx}},{\mathrm{ic}}_{\mathrm{ctx}}\right)+\\ w_{\mathrm{reqs}}*\mathrm{sim}\left({\mathrm{iq}}_{\mathrm{reqs}},{\mathrm{ic}}_{\mathrm{reqs}}\right)\end{array}}{w_{\mathrm{goal}}+w_{\mathrm{ctx}}+w_{\mathrm{reqs}}}.$

The global integration case similarity measure weights the local similarity measures for the three categories in the problem description to determine the global similarity measure. This measure may be used to determine if the integration case is similar to the integration problem. The above calculations may be performed for many different integration cases. The most similar integration cases may then be determined and provided to the service integrator.

Method Flow

FIG. 7 depicts a simplified flowchart 700 for performing case-based retrieval according to one embodiment. The following uses a wizard-based questionnaire to define the integration problem. The service integrator can answer questions regarding the problem and be provided with similar integration cases. At 702, an integration goal definition is received. FIG. 8a shows an interface used by the service integrator to define the integration goal attributes according to one embodiment. Questions to define the attributes of the type of enterprise system that should be extended, the flexibility of use case that should be implemented, and the principle integration of the integration flavor are shown. A drop down menu of predefined options may be provided to the service integrator to define the attributes.

Referring back to FIG. 7, at 704, the integration context definition is received. FIG. 8b shows an interface used by service integrator to input the integration context definition according to one embodiment. Questions to define the attributes for the service, the functional business semantics, the business area, the UI components, and the process components are shown. The answers to the questions define values of the attributes.

Referring back to FIG. 7, at 706, the integration requirements definition is received. FIGS. 8c and 8d depict interfaces that allow a service integrator to input information for the integration requirements attributes according to one embodiment. Questions to define data access attributes for persisting data, reading data, writing data, and accessing additional logic are shown in FIG. 8c. In FIG. 8d, questions to define attributes for process extension requirements are shown in FIG. 8d. Although not shown, other questions to define attributes for business logic extensions, technical integration requirements, and non-functional integration requirements may be provided.

Referring back to FIG. 7, at 708, in an optional step, a configuration of similarity measures may be received. This configures which similarity measures may be used for different attributes. FIG. 8e shows an interface that allows a service integrator to input similarity measures to be used with different attributes according to one embodiment. For example, similarity measures for integration goals, integration contexts, and integration requirements may be input. A similarity measure may be selected at 802. Also, a weight for that similarity measure may be input at 804. The weight indicates the weighting that is provided to that similarity measure.

Referring back to FIG. 7, at 710, integration cases that are similar to the integration problem are retrieved. For example, a certain number of integration cases that are deemed to be the most similar (e.g., have a similarity above a threshold) may be retrieved. FIG. 8f shows an example of retrieved results according to one embodiment. As shown, four different integration cases have been retrieved and ranked based on their similarity. The results show the similarity rating, business area, service, UI model, and process model.

At 712, a selection of an integration case is received from a service integrator. The problem solution of the integration case may then be adapted for the integration problem.

A service integrator may also want to know more details about the retrieved integration cases. In this case, the service integrator may select an integration case and be provided with more details as shown in FIGS. 8h and 8i.

Description of Standard Enterprise System

The case-based retrieval method may be used in extending standard enterprise systems. Standard enterprise systems may be described with a single overall abstracted model that spans across four abstraction layers, such as the presentation layer, business process layer, service layer, and business configuration layer. An enterprise system includes multiple business applications or reference processes that leverage a common service and business configuration layer. FIG. 9 shows a more detailed example of an enterprise system 900 according to one embodiment. Enterprise system 900 may be described with a single overall abstracted model that spans across a number (e.g., four) of abstraction layers, such as a presentation layer 902, a business process layer 904, a service layer 906, and a business configuration layer 908. Enterprise system 900 includes multiple (service-based) business applications that leverage a common service layer 906 and business configuration layer 908.

Presentation layer 902 comprises all artifacts and components for a service integrator interface (UI) part of the business application. In one embodiment, UI components (UI views 910) for a dedicated UI platform with all interrelations are located within presentation layer 902. The service integrator interface will be described in more detailed below.

Business process layer 904 contains models 912 of business processes 914 that are realized within the business application. Modeling elements for business processes may contain references to elements on other layers. For example, a human activity in a business process can refer to a UI component 910 with the implementation of the human service integrator interface. An automated activity can refer to a service declared in the service layer 906 with the implementation of the needed business functionality.

Service layer 906 contains services offered by enterprise system 900. Core services provide access to business objects. Composite services represent compositions of core services into larger bundles to provide advanced higher-value business functionality or application logic.

Business configuration layer 908 contains the configuration data for business applications with available parameters and configuration options (also known as ‘customizing’) for business applications.

In order to adapt standard business applications to customer specific needs, enterprise systems 900 provide a large set of proprietary extensibility/adaptability features 916.

Example of Enterprise System Adaptation

The integration of services into the enterprise systems will now be described. In order to adapt standard business applications to customer specific needs, enterprise systems include proprietary extensibility/adaptability features. The following describes an example of an extension of a service to a standard enterprise system.

FIG. 10 shows an example of an interface 1000 of a business application according to one embodiment. As a result of legal changes in export guidelines, a manufacturer of car seats has to certify its products to guarantee that materials used within the car seat comply with environmental laws. The core version of business application does not support the calculation of eco values for a given car seat. Thus, the business application needs to be extended to support this calculation.

The missing functionality has been created and published as a service on the service marketplace by a service provider. The service allows the calculation of eco values for products including certification. A product designer as a service integrator of a product lifecycle management (PLM) application in the company wants to extend business application with this missing kind of functionality. The product designer takes the role of a service consumer and accesses the service marketplace directly from within the business application. The product designer searches for services that provide the missing functionality and receives a list of matching services from various service providers certified for enterprise system 900. According to a working context, the designer selects a service called “Eco-Calculator” and purchases it on the marketplace.

Subsequently the service is automatically integrated into the core business application without running a manual integration project. The following extensions are performed to the core business application to extend interface 1000 with (1) an additional table column 1002 (“Eco Value”) in a product components table 1004, (2) an additional button 1006 (“Calculate Eco Value”) and (3) an additional field 1008 indicating the total eco value for the car seat (“Entire Eco Value”).

After the service is integrated into the business application, the service can be used by the product designer to calculate eco values for a given bill of material. If the total eco value fulfils the legal requirements, a certificate is generated and passed to the consumer application.

This scenario shows an example for extending a core UI component with additional UT elements. Based on the same principles a core process model can be extended, e.g., by inserting additional process steps.

Conclusion

Particular embodiments provide many advantages. For example, a systematic, tool-supported definition of retrieval of existing integration knowledge is provided. The case-based retrieval framework provides a platform with a rich knowledge base for the systematic, tool-supported definition and retrieval of integration cases already solved in the past. This allows systematic reuse of valuable integration-, adaptation and extension experience of past implementation projects. The framework allows specification of new integration problems and retrieval of existing integration cases that are similar to a new integration problem to be solved by applying similarity measures within a case retrieval algorithm. The knowledge base allows for a search of extension size adaptation knowledge of past integration projects.

The description and retrieval of similar, existing integration cases on a problem space level using integration cases is provided. Integration scenarios may be described using a set of attributes formulated in a meta-model. Search and re-use steps may then build upon the abstracted information on a problem space level. This enables gathering of integration requirements for a central questionnaire as disclosed in the interfaces described in FIGS. 8a-8h and enables searching for existing integration cases with similar integration requirements and the corresponding solutions.

Also, the description and retrieval of integration scenarios on a problem space level includes scenarios within extension/adaptation needs of different application layers of the enterprise system. Integration cases cover extension/adaptation as well as service mediation needs in a single format. Problem descriptions of integration cases include requirements/integration needs of various application layers in categories. This allows systematic searches for existing integration cases with similar integration requirements/needs of one of the categories.

System Diagram

FIG. 11 illustrates hardware of a special purpose computing machine configured with a case-based retrieval framework according to one embodiment. An example computer system 1110 is illustrated in FIG. 11. Computer system 1110 includes a bus 1105 or other communication mechanism for communicating information, and a processor 1101 coupled with bus 1105 for processing information. Computer system 1110 also includes a memory 1102 coupled to bus 1105 for storing information and instructions to be executed by processor 1101, including information and instructions for performing the techniques described above, for example. This memory may also be used for storing variables or other intermediate information during execution of instructions to be executed by processor 1101. Possible implementations of this memory may be, but are not limited to, random access memory (RAM), read only memory (ROM), or both. A storage device 1103 is also provided for storing information and instructions. Common forms of storage devices include, for example, a hard drive, a magnetic disk, an optical disk, a CD-ROM, a DVD, a flash memory, a USB memory card, or any other medium from which a computer can read. Storage device 1103 may include source code, binary code, or software files for performing the techniques above, for example. Storage device and memory are both examples of computer readable storage mediums.

Computer system 1110 may be coupled via bus 1105 to a display 1112, such as a cathode ray tube (CRT) or liquid crystal display (LCD), for displaying information to a computer service integrator. An input device 1111 such as a keyboard and/or mouse is coupled to bus 1105 for communicating information and command selections from the service integrator to processor 1101. The combination of these components allows the service integrator to communicate with the system. In some systems, bus 1105 may be divided into multiple specialized buses.

Computer system 1110 also includes a network interface 1104 coupled with bus 1105. Network interface 1104 may provide two-way data communication between computer system 1110 and the local network 1120. The network interface 1104 may be a digital subscriber line (DSL) or a modem to provide data communication connection over a telephone line, for example. Another example of the network interface is a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links are another example. In any such implementation, network interface 1104 sends and receives electrical, electromagnetic, or optical signals that carry digital data streams representing various types of information.

Computer system 1110 can send and receive information through the network interface 1104 across a local network 1120, an Intranet, or the Internet 1130. In the Internet example, software components or services may reside on multiple different computer systems 1110 or servers 1131-1135 across the network. The processes described above may be implemented on one or more servers, for example. A server 1131 may transmit actions or messages from one, component, through Internet 1130, local network 1120, and network interface 1104 to a component on computer system 1110. The software components and processes described above may be implemented on any computer system and send and/or receive information across a network, for example.

Particular embodiments may be implemented in a non-transitory computer-readable storage medium for use by or in connection with the instruction execution system, apparatus, system, or machine. The computer-readable storage medium contains instructions for controlling a computer system to perform a method described by particular embodiments. The instructions, when executed by one or more computer processors, may be operable to perform that which is described in particular embodiments.

As used in the description herein and throughout the claims that follow, “a”, “an”, and “the” includes plural references unless the context clearly dictates otherwise. Also, as used in the description herein and throughout the claims that follow, the meaning of “in” includes “in” and “on” unless the context clearly dictates otherwise.

The above description illustrates various embodiments of the present invention along with examples of how aspects of the present invention may be implemented. The above examples and embodiments should not be deemed to be the only embodiments, and are presented to illustrate the flexibility and advantages of the present invention as defined by the following claims. Based on the above disclosure and the following claims, other arrangements, embodiments, implementations and equivalents may be employed without departing from the scope of the invention as defined by the claims.

APPENDIX A

TABLE 1
Case Attributes - Integration Goal Specification
	Attribute
Attribute/Feature	Type	Description and Values
TargetBusinessSystemType	Symbol	Defines the enterprise system
		that should be extended/
		adapted.
		Values:
		SAP CRM (Customer
		Relationship Management)
		SAP ERP (Enterprise Resource
		Planning)
		SAP PLM (Product Lifecycle
		Management)
		SAP SCM (Supply Chain
		Management)
		SAP SRM (Supplier
		Relationship Management
		SAP Business ByDesign
		Other
UsageScenario	Symbol	Defines the customizing or
		flexibility use case that should
		be implemented.
		Values:
		Third Party Service Integration
		Field Extensibility
		Custom Forms
		Others
IntegrationFlavor	Symbol	Defines the principle integration
		flavor of the service in the target
		consumption environment of the
		enterprise system.
		Values:
		UI Integration - extension of
		single UI component
		UI Integration - extension of
		multiple UI components
		Process Integration - extension
		of single process component
		Process Integration - extension
		of multiple process components
		UI and Process Integration -
		cross-layer extension

TABLE 2
Case Attributes - Integration Context Specification
	Attribute
Attribute/Feature	Type	Description and Values
Service Context (= Service Provider Context)
ServiceToBeIntegrated	Model	Defines the service (e.g.
		provided by an ISV or eco
		system partner) that should
		be integrated into the target
		enterprise system. Service is
		modeled in a service
		ontology based on USDL)
ServiceBusinessSemantics	Taxonomy	Defines the business semantics
		of the service to be integrated.
		Values of this attribute are
		provided by a business
		domain ontology.
Enterprise System Context (= Service Consumer Context)
TargetEnterpriseSystem	Taxonomy	Defines the business semantics
FunctionalArea		of the target components in the
		enterprise system that should
		be extended by the
		complementary service. Values
		of this attribute are provided by
		a business domain ontology.
TargetUIComponent(s)	Model	Defines the target UI
		component(s) of the enterprise
		system that should be extended/
		adapted (in case of UI
		components are involved in
		the selected integration flavor).
		UI components are described
		by an UI ontology that is based
		on Diamodl (abstract UI
		description language) and
		includes dedicated extension
		points.
TargetProcessComponent(s)	Model	Defines the target process
		component(s) of the enterprise
		system that should be extended/
		adapted (in case of process
		components are involved in the
		selected integration flavor).
		Process components are
		described by an BPMN
		Ontology that includes dedicated
		extension points.

TABLE 3
Case Attributes - UI Extension Requirements
	Attribute
Attribute/Feature	Type	Description and Values
TextualDescription	String	Textual description of the
Requirements		integration requirements.
ReqUITriggerOfService	Symbol	Defines how the service should be
		triggered within the core UI
		component.
		Values (multiple selection):
		Not Relevant
		No trigger required
		Trigger by an existing UI event
		Trigger by adding a new button
		Trigger by adding a new menu
		item
		Required - adding multiple triggers
ReqUIExtensionService	Symbol	Defines whether the core UI
Input		component needs to be extended
		with additional UI controls in order
		to gather information that is
		required as input data to call
		the integrated service.
		Values (multiple selection
		possible):
		Not Relevant
		Not Required
		Required - adding a new tab
		control
		Required - adding a new panel
		Required - adding a new form item
		Required - adding a new checkbox
		Required - adding a new list box
		Required - adding a new combo-
		box
		Required - adding a new tree item
		Required - adding multiple
		extensions
ReqUIExtensionService	Symbol	Defines whether the core UI
Output		component needs to be extended
		with additional UI controls
		in order to show/display result
		values of the service invocation.
		Values (multiple selection
		possible):
		Not Relevant
		Not Required
		Required - adding a new table
		column
		Required - adding a new table
		Required - adding a new tab
		control
		Required - adding a new panel
		Required - adding a new form item
		Required - adding a new checkbox
		Required - adding a new list box
		Required - adding a new combo-
		box
		Required - adding multiple
		extensions
. . .	. . .	. . .

TABLE 4
Case Attributes - Process Extension Requirements
	Attribute
Attribute/Feature	Type	Description and Values
ReqPETriggerOfInteraction	Symbol	Defines the initiator (triggering
		component) of a process
		extension scenario.
		Values:
		Not Relevant
		Core Process triggers Extension
		Extension triggers Core Process
ReqPEPluginPosition	Symbol	Defines the position in respect to
ExtensionProcess		the core process where an
		extension process should be
		plugged in.
		Values:
		Not Relevant
		Plugin - Before Core Process
		Plugin - Into Core Process
		Plugin - After Core Process
ReqPEDataFlowCpToEx	Boolean	Defines whether data should
		flow from the core process to the
		extension process.
		Values:
		No/Yes
ReqPEDataFlowExToCp	Boolean	Defines whether data should
		flow from the extension process
		to the core process.
		Values:
		No/Yes
ReqPECommunication	Symbol	Defines the communication
Mode		mode between the core process
		and the extension process.
		Values:
		Not Relevant
		Asynchronous
		Synchronous
ReqPEMultiple	Boolean	Defines whether multiple core
InvolvedCP		processes are involved in the
		integration scenario.
		Values:
		No/Yes
ReqPEMultiple	Boolean	Defines whether multiple
InvolvedEx		extension processes are involved
		in the integration scenario.
		Values:
		No/Yes
. . .	. . .	. . .

TABLE 5
Case Attributes - Business Logic Extension Requirements
	Attribute
Attribute/Feature	Type	Description and Values
ReqBLEDataPersistence	Symbol	Defines whether data returned
		from the service should be
		persisted in the target enterprise
		system environment.
		Values:
		Not Required
		Required - data should be
		persisted in an existing table
		of the target system
		Required - data should be
		persisted in an additional
		column of an existing table
		Required - data should be
		persisted in a new table
		Required - data should be
		persisted in an existing
		field of a business object
		Required - data should be
		persisted in a new field of a
		business object
ReqBLEReadAccessTo	Boolean	Defines whether the integration
EnterpriseSystem		logic has to read data from the
		core enterprise system.
		Values:
		Not Required/Required
ReqBLEWriteAccessTo	Boolean	Defines whether the integration
EnterpriseSystem		logic has to write data into
		the core enterprise system.
		Values:
		Not Required/Required
ReqBLEAccessBusiness	Boolean	Defines whether the integration
LogicOfEnterpriseSystem		logic needs to access additional
		business logic on the core
		enterprise system.
		Values:
		Not Required/Required
ReqBLEInteractive	Symbol	Defines whether an interactive
Service integratorTask		service integrator task is
		required in the integration
		logic.
		Values:
		Not Required
		Required - before a service
		operation is called
		Required - after service
		operation is called
ReqBLEManualService	Symbol	Defines whether a human
integratorTask		service integrator task is
		required in the integration logic.
		Values:
		Not Required
		Required - before a service
		operation is called
		Required - after service
		operation is called
ReqBLEAdjustCustomizing	Symbol	Defines whether a customizing
Parameter		parameter has to be set/adjusted
		in the target enterprise system.
		Values:
		Not Required
		Required - on single customizing
		parameter
		Required - on multiple
		customizing parameters
ReqBLEAddCustomizing	Symbol	Defines whether a new
Parameter		customizing parameter has
		to added in the target
		enterprise system.
		Values:
		Not Required
		Required - add single
		customizing parameter
		Required - add multiple
		customizing parameters
. . .	. . .	. . .

TABLE 6
Case Attributes - External Service Integration Requirements
	Attribute
Attribute/Feature	Type	Description and Values
ReqSIUsageOfB2BStandards	Symbol	Defines whether standard B2B
		protocols should be used
		for the communication with
		the external service.
		Values:
		No Standard Used
		RosettaNet
		CIDX
		EDI/EDIFACT
		Others
ReqSITechnicalProtocol	Symbol	Defines which technical
		communication protocol
		should be used for the
		communication with
		the external service.
		Values:
		SOAP
		WS Reliable Messaging
		REST
		JMS
		HTTP
		ALE/IDOC
		RFC
		EDI
		Others
. . .	. . .	. . .

TABLE 7
Case Attributes - Non-Functional Integration Requirements
	Attribute
Attribute/Feature	Type	Description and Values
ReqNFRAuthentication	Boolean	Defines whether the
		integration logic needs to
		authenticate in the
		communication with the
		external service.
		Values:
		Not Required/Required
ReqNFRCaching	Boolean	Defines whether the
		communication is
		performance critical and
		if caching mechanisms
		are required.
		Values:
		Not Required/Required
ReqNFRLogging	Boolean	Defines whether the
		communication with the
		external service should be
		logged.
		Values:
		Not Required/Required
ReqNFREncryption	Boolean	Defines whether the messages
		sent to the service or received
		from the service should be
		encrypted.
		Values:
		Not Required/Required
ReqNFRDigitalSignature	Boolean	Defines whether the messages
		sent to the service or received
		from the service should be
		digitally signed (e.g. as
		required by legal).
		Values:
		Not Required/Required
ReqNFRTransactionHandling	Boolean	Defines whether some specific
		transaction handling is
		required.
		Values:
		Not Required/Required
. . .	. . .	. . .

Claims

1. A method comprising: storing a set of integration cases previously used for adapting a standard enterprise system, wherein integration cases include a problem description and a problem solution for the adapting of the standard enterprise system;receiving an integration problem for extending the standard enterprise system, the integration problem having a problem description and not a problem solution;determining, by a computing device, a similarity between the problem description of the integration problem and the problem description of the set of integration cases;determining one or more similar integration cases from the set of integration cases to the integration problem based on the determined similarity; andoutputting the one or more similar integrations cases to a user, wherein the problem solution for a similar integration case is usable to determine the problem solution for the integration problem.

2. The method of claim 1, wherein: the problem description for the integration problem comprises a first set of attributes,the problem descriptions for the set of integration cases comprise a second set of attributes, andthe similarity is determined between the first set of attributes and each of the second set of attributes.

3. The method of claim 2, further comprising determining a plurality of local similarity measures based on a comparison of similar attribute types in the first set of attributes and the second set of attributes for a respective integration case.

4. The method of claim 3, wherein determining the similarity comprises computing a global similarity measure based on the plurality of local similarity measures.

5. The method of claim 4, wherein computing the global similarity measure comprises aggregating the plurality of local similarity measures according to a weighted aggregation function.

6. The method of claim 1, wherein the problem description for the integration problem and an integration case includes an integration goal description describing a goal to be achieved by the integration of the integration problem.

7. The method of claim 1, wherein the problem description for the integration problem and an integration case includes an integration context description describing a context of the integration of the integration problem.

8. The method of claim 1, wherein the problem description for the integration problem and an integration case includes an integration requirements description describing requirements of the integration of the integration problem.

9. The method of claim 1, wherein determining the similarity comprises computing local similarity measures for an integration goal description, an integration context description, and an integration requirements description.

10. The method of claim 9, wherein determining the similarity comprises computing a global similarity measure using the local similarity measures for the integration goal description, the integration context description, and the integration requirements description.

11. The method of claim 1, wherein receiving the integration problem comprises: outputting a questionnaire;receiving answers to questions for the integration problem on the questionnaire; andgenerating the problem description for the integration problem from the answers.

12. The method of claim 11, further comprising: determining attribute values from the answers to the questions; andusing the attribute values to determine the similarity between the integration problem and the set of integration cases.

13. The method of claim 1, further comprising storing a new integration case including the problem description of the integration problem and a problem solution that has been adapted from the problem solution of a similar integration case.

14. A non-transitory computer-readable storage medium containing instructions for controlling a computer system to be operable to: store a set of integration cases previously used for adapting a standard enterprise system, wherein integration cases include a problem description and a problem solution for the adapting of the standard enterprise system;receive an integration problem for extending the standard enterprise system, the integration problem having a problem description and not a problem solution;determine a similarity between the problem description of the integration problem and the problem description of the set of integration cases;determine one or more similar integration cases from the set of integration cases to the integration problem based on the determined similarity; andoutput the one or more similar integrations cases to a user, wherein the problem solution for a similar integration case is usable to determine the problem solution for the integration problem.

15. The computer-readable storage medium of claim 14, wherein: the problem description for the integration problem comprises a first set of attributes,the problem descriptions for the set of integration cases comprise a second set of attributes, andthe similarity is determined between the first set of attributes and each of the second set of attributes.

16. The computer-readable storage medium of claim 15, further operable to determine a plurality of local similarity measures based on a comparison of similar attribute types in the first set of attributes and the second set of attributes for a respective integration case.

17. The computer-readable storage medium of claim 14, wherein determine the similarity comprises compute local similarity measures for an integration goal description, an integration context description, and an integration requirements description.

18. The computer-readable storage medium of claim 17, wherein determine the similarity comprises compute a global similarity measure using the local similarity measures for the integration goal description, the integration context description, and the integration requirements description.

19. The computer-readable storage medium of claim 14, wherein receive the integration problem comprises: output a questionnaire;receive answers to questions for the integration problem on the questionnaire; andgenerate the problem description for the integration problem from the answers.

20. An apparatus comprising: one or more computer processors; anda computer-readable storage medium comprising instructions for controlling the one or more computer processors to be operable to:store a set of integration cases previously used for adapting a standard enterprise system, wherein integration cases include a problem description and a problem solution for the adapting of the standard enterprise system;receive an integration problem for extending the standard enterprise system, the integration problem having a problem description and not a problem solution;determine a similarity between the problem description of the integration problem and the problem description of the set of integration cases;determine one or more similar integration cases from the set of integration cases to the integration problem based on the determined similarity; andoutput the one or more similar integrations cases to a user, wherein the problem solution for a similar integration case is usable to determine the problem solution for the integration problem.