US20100083221A1 - System and method for automated re-architectureing of legacy systems using object oriented language - Google Patents

System and method for automated re-architectureing of legacy systems using object oriented language Download PDF

Info

Publication number
US20100083221A1
US20100083221A1 US12298528 US29852808A US2010083221A1 US 20100083221 A1 US20100083221 A1 US 20100083221A1 US 12298528 US12298528 US 12298528 US 29852808 A US29852808 A US 29852808A US 2010083221 A1 US2010083221 A1 US 2010083221A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
data
legacy
pattern
system
re
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
US12298528
Other versions
US8819621B2 (en )
US20110035725A9 (en )
Inventor
Ravindra Naik
Amit Saxena
Narayan Ramaswami
Thirthahalli Shivaprasad
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Tata Consultancy Services Ltd
Original Assignee
Tata Consultancy Services Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/70Software maintenance or management
    • G06F8/72Code refactoring

Abstract

The present invention relates to method of defining multiple program abstractions, extraction methodologies, transformation, and code conversion to convert legacy monolithic architecture of business systems to a layered modern architecture using Object Oriented language such as Java.

Description

    FIELD OF THE INVENTION
  • [0001]
    The present invention relates to an automated re-architecting of legacy systems using object-oriented language.
  • [0002]
    The present invention relates to method of defining multiple program abstractions, extraction methodologies, transformation, and code conversion to convert legacy monolithic architecture of business systems to a layered modern architecture using Object Oriented language such as Java. The term architecture is used to signify the, static structure of the system and can be related to technical architecture as commonly known in the software world. The term “re-architecting” specifies the modification of architecture of the business systems into different architecture implicitly indicating the protection of the functionality of the system while performing the re-architecting.
  • [0003]
    This automated re-architecting is achieved by recognizing instances of architectural and design patterns, extracting the instances into a repository, optimize these instances and using them for converting/generating target architecture based system using object oriented language.
  • PRIOR ART References
  • [0004]
    U.S. Pat. No. 6,467,079 A computer-implemented method in which report program language is converted to object-oriented source code, such as Java, using the report program language compiler. The object-oriented source code emulates the behaviour of the report program language, such as VARPG. Applications written in RPG are converted to Java and therefore can run on every platform for which a Java virtual machine exists. RPG programmers now have the ability to write internet applications. Java applications and applets can be written in RPG and existing RPG applications can be converted to Java applets. templates having code that is selectable based upon the applicable case. In one implementation, the source language is translated to target language code which is, in turn, compiled by a target language compiler, thereby providing a two-step source language compiler.
  • [0005]
    U.S. Pat. No. 6,389,385 A safe system and method for reversibly translating source code between unlike character sets, or formats, includes a mapping table of syntactically necessary characters and, possibly, other frequently used characters, for translating source characters from a first format to a second format. A marker character is used to replace other characters in the source code while preserving the original, replaced source characters in a comment file. Upon reverse translating, syntactically necessary characters are translated back into the first format using the mapping table, and marker characters are replaced by original source characters from the comment file.
  • [0006]
    U.S. Pat. No. 6,389,588 A method of extracting and transforming a business rule which is a self contained section of legacy code focused on the computation of specific business policy includes identifying the business rule. Thereafter, the business rule code is located in the existing program and extracted in human readable code form. New code is generated for a new application for containing the business rule therein, and the new code is integrated into the new application. A system for extracting and transforming such business rules from existing programs such as legacy applications to a new application includes various components for achieving the various noted steps.
  • [0007]
    U.S. Pat. No. 6,018,627 A programmed computer system includes a set of development tools, each having a format used to store data and code files. The output data from a developmental tool is transformed into a generic format data which is saved in a repository. The repository also contains all output data, application components, and information as to the relationship between the entities and objects stored in the repository. Each tool employed during the development process puts information into the repository and takes information out of the repository. In this way, the system integrates the tools used in different parts of the development process by passing necessary information from one tool to another. Different tools are employed through each of the development stages, legacy integration, enterprise modeling, domain modeling, writing and editing of business logic, generating skeleton code, component building and wrapping and application deployment.
  • [0008]
    U.S. Pat. No. 6,334,215 A method for migrating legacy applications into a new software product architecture using a functional conversion module located within a system controller. The functional conversion module comprises a migration plan shut off. The functional conversion module further comprises three paths or branches through which a functional request can be routed. Functional requests which are not identified in the migration plan are routed through the first path and the functional request is sent to the pre-existing software and executed as requested. Functional requests identified in the migration plan for which the pre-existing software is in control are routed through the second path, and the functional request is sent to the pre-existing software and executed as received. In the background, the functional request is translated for the new software and sent to the new software and executed. Functional requests identified in the migration plan for which the new software is in control are routed through the third path, and the functional request is translated for the new software and sent to the new software and executed. If the pre-existing software has been shut off, the task is complete. If the pre-existing software is not identified as being shut off, the functional request is sent to the pre-existing software and executed as received in the background. Duplicate requests are suppressed by the system controller.
  • BACKGROUND OF THE INVENTION
  • [0009]
    Businesses have invested money, time, and resources in computers and computer systems which store and access large quantities of data relating to specific matters, such as financial accounts, inventory, customers, employees, etc. Businesses are sensitive to the loss of their investment when new computer technology arises which may result in their investments becoming obsolete. An important consideration, therefore, in introducing new computer technology is its adaptation with existing computer technology.
  • [0010]
    Many organizations are forced to employ the expensive approach of re-writing the software from scratch. This is because there are no techniques that are ably supported by tools to re-architect the legacy software to the chosen open environment and architecture, while making effective use of the features of the new environment.
  • [0011]
    Modern architecture like Service oriented architecture (SOA), web services are gaining popularity. These architectures provide better re-usability and access within and across the organization. Monolithic Legacy architecture however provides a closed environment and cannot operate with SOA based applications.
  • [0012]
    Though wrappers can be provided to make old logic into services, the real benefits can be observed where Legacy architecture is migrated to modem SOA architecture.
  • [0013]
    Object-oriented” programming (OOP) is gaining popularity as it provides benefits over procedural programming. OOP languages, such as Smalltalk, C++, and Java, allow programmers to approach their programming tasks in a way that is believed to be more natural and intuitive than the rigidity of the procedural programming languages. The main problem, however, is that an OO architecture does not inherently interface smoothly with architecture of Legacy systems in which businesses may have a substantial investment.
  • [0014]
    Therefore there is a dire need to develop a system which provides easier conversion path to utilize new architecture and that has a flexible and a smooth interface. The present invention aims at developing such system.
  • [0015]
    The goal of OOP is to reduce the time and costs associated with developing complex software by creating small, reusable sections of program code that can be quickly and easily combined and reused to create new programs. The code sections are known as objects. The software object may model the attributes or characteristics of the real-world object and, in many cases, may also model its behavior.
  • [0016]
    Despite the recent development of modern architecture like SOA and dedicated OOP languages, businesses can't take the benefits of these state of the art practices since they have already invested billions of dollars over the years in their existing systems and procedural code. It would be an extraordinarily uneconomical task to manually transfer all legacy procedural codes into OOP codes following modern architecture. It is a known-to-be-difficult problem. Obsolete documentation, core programmers are no longer available and the structure of the system is not known, are some of the main reasons. The known techniques of syntactic (one-to-one) conversion (as claimed in U.S. Pat. No. 6,467,079 and U.S. Pat. No. 6,453,464) are not suitable since they do not result in architectural modifications to take the real benefits.
  • [0017]
    It is the object of the invention to provide a method and system that can re-architect the legacy code in an automated fashion. This automated re-architecting is achieved by recognizing instances of architectural and design patterns, identifying instances and using these instances for generating/transforming to object oriented code.
  • [0018]
    It is the object of the invention to establish and define architectural and design patterns, taking into account the variants of programming languages and styles.
  • [0019]
    It is yet another object of the invention to establish criteria to generate or convert the existing legacy code into OO code based on multiple patterns.
  • [0020]
    It is yet another object of the invention to link the converted instances of the patterns to build a functionally equivalent re-architected application.
  • [0021]
    It is yet another object of the invention to migrate legacy programs irrespective of the platforms.
  • SUMMARY OF THE INVENTION
  • [0022]
    The invention is directed to a method and system of defining patterns for identifying various abstractions in legacy systems, and transforming the legacy system, based on the identified instances of patterns, into a new system following modern layered architecture using object oriented language.
  • [0023]
    The present invention addresses the problem of re-architecting by defining abstractions that are based on the architectural and design aspects. By recognizing occurrences of such patterns in the legacy code, the implicit architecture and design may be recovered.
  • [0024]
    The present invention aims at defining appropriate abstractions, and assists architecture and design recovery by tool based recognition of the patterns in the legacy programs. Using domain and context knowledge to parameterize the extraction algorithms, the present invention maps the program elements to pre-defined, open architecture patterns.
  • [0025]
    The present invention also addresses the conversion of the pattern instances into modern object-oriented implementation.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0026]
    FIG. 1 describes the method and system for automated re-architecting of legacy systems using object-oriented language.
  • [0027]
    FIG. 1 describes the method and system of re-architecting the legacy systems into modern architecture using object oriented language. First a pattern definitions repository (1) is prepared that includes definition of various patterns including services (2), validations (3), data access (4), data entities (5), user message (6), user interface (7), and data definition (8). These patterns are specified (9) in a workbench (12) for creating individual pattern matchers (16) corresponding to each pattern, to identify the occurrence of the pattern in the legacy system (13). Programming language syntax (11) and known programming styles (10) of the legacy system are used to specify (9) these patterns using specification language into the workbench (12) to generate pattern matchers (16).
  • [0028]
    The legacy system (13) is parsed using a language specific parser (14), control flow analysis and data flow analysis is performed using program analyzer (15). A modern architecture is finalized as the target architecture (33) for the re-architecting. This architecture decides the kinds of different classes, which will be present in the re-architected application. As a first step of the pattern matching, the data entity matcher (18) traverses through the legacy program and captures all the information about all the data entities used in the program to create and map to the corresponding classes.
  • [0029]
    Multiple pattern matchers extract the user interface (24), user messages (22), data definitions (25) and data access (23). Service pattern matcher (20) identifies services in legacy application and validation pattern matcher (19) identifies validations in the legacy application. Computation pattern matcher (21) identifies all program statements that are part of the computations. After pattern matching is completed, the different pattern instances are available, which are stored in the pattern instance repository (26). There is an optional step of optimization (27), which is performed on the extracted pattern instances to optimize the output extracted from the pattern matchers (16). For the conversion of extracted pattern instances (26) a conversion rules specification (30) is prepared with the mapping of legacy language (11) and object-oriented language (28) and specified into the workbench (12) to create the converter tool (31). The user interface (40) and user message classes (38) are generated using the code generator (32). Data definitions (41) and data access classes (39) are generated by the code generator (32). Methods converted from legacy system are added into Service classes (34) and Domain classes (35). Validation methods (37) converted from legacy system are added to the domain classes (35). All other data entities are generated as classes (36) in the re-architected application.
  • [0030]
    All the application elements of the system are integrated using the packager (42) as per the definition of the target architecture (33) to create the re-architected system (43).
  • DETAILED DESCRIPTION OF PRESENT INVENTION
  • [0031]
    Any Legacy application (or any application for that matter) can be envisaged to have pre-defined set of logic to achieve the required functionality. Different elements of the application work together to achieve one or more than one goals required for successful execution of the application. These application elements belong to different abstractions and map to basic building blocks of an application system. Primary building blocks are user interfaces, user messages, services, validations, data access/save, and computations. There can be whole set of other building blocks such as user interface navigation, service flows, invocation of business logic, grouping of business logic etc. The present invention provides a method and system to extract different building blocks in a definitive way, transforming them by adopting the modern design patterns and styles, and re-joining these building blocks to formulate a new application that behaves as the original application.
  • [0032]
    The significant abstractions are Services, Validations, Data Access and Domains that represent the behavior of the application. There are other abstractions needed to complete the application user interfaces and data definitions, which are commonly known.
  • Pattern Definitions and Extraction
  • [0033]
    Based on different programming styles for an abstraction in a program, many different patterns can be defined. So there can be multiple patterns for the same abstraction. Some of the patterns are dependent on the specific features provided by the programming language while others depend on programming styles and may vary from program to program.
  • [0034]
    Variations in pattern instances can be seen as a consequence of less formally defined pattern, or more rigorous interpretation of the pattern. In either case, it adds to the challenge of automatic recognition of the pattern. To handle variations in pattern instances, pattern algorithms parameterized by domain and context information are created.
  • [0035]
    Extraction of patterns is based on the structural properties, static data-flow and control-flow analysis of the programs. We search and traverse the analysis information of programs to match the patterns, and mark the code when a match is found. Certain pieces of code may match multiple patterns, or certain patterns may have no matches.
  • Services
  • [0036]
    Service denotes an atomic unit of domain functionality (in case of a banking domain example services are deposit, withdraw, transfer, etc.), or it can denote a structural but cohesive unit of work (example services are populate screen, process screen, etc.). This pattern aims to segregate the code into modular blocks.
  • [0037]
    To identify services in legacy software systems, two types of service patterns are defined. Structural Services Pattern—This pattern is defined based on how program is structured to achieve a business function. The definition involves user interaction statements within a program and the control flow surrounding those statements. This pattern enables to extract the services based on the structural properties of the program.
  • [0038]
    Functional Service Pattern—This pattern is defined based on how specific program variables are taking different values and the statements getting executed for a selected value, wherein each value represents a desired business function. This pattern utilizes the preliminary program understanding in terms of identifying program variables that are used to control a particular functionality. This pattern helps extract the services based on the specific variable values in the program. Once the services are identified, the flow between services is also identified using the control flow of the legacy programs and extracted as service workflow. This information is utilized for service orchestration in the target architecture.
  • Validations
  • [0039]
    Validations are checks of data that comes into the application from external sources like user screen or data store or external subsystem. The checks may be edit-checks or business validations. In particular, the checks may be mandatory checks (checks to ensure non-null values), edit checks (checks to ensure valid type of data) or value checks (checks to ensure valid range of values) or table look-up checks. When the validation checks fail, error handling and error recovery is required—this is also part of validations.
  • [0040]
    FIG. 2 describes the method and system for validation of parameters.
  • [0041]
    Validation patterns (201), like other patterns, are parameterized to ensure that the pattern method can be used to capture many different types of validations. The parameters are used to specify the context—error message, data entities containing the error code, or subroutine that handles errors (202).
  • [0042]
    In the preliminary step, we identify the statements specified as parameters In the next step, we identify all the controlling checks (203) that lead to the execution of the identified statements. The controlling checks help decide the type of validation and the associated tables (if it is a table look-up check).
  • [0043]
    Next, we determine the screen fields (204) or data store fields (205) whose values are checked in the validations, and the data store fields which are updated using the values of so-identified screen-fields (204).
  • [0044]
    We then cluster a set of checks together to form a validation rule. Every validation rule is associated with one or more screen fields (204) or data store fields (205), and has associated error handling.
  • Data Access
  • [0045]
    Business systems are data driven and contain logic to store/retrieve information from persistent stores, such as a relational database. In most legacy applications the data access logic is tightly integrated with business logic and application programs are aware of underlying schema for the data entities. In modern applications, the data access operations are separated and implemented in a separate persistent layer. This insulates the business logic from any change in underlying schema and hence minimizes impact of such changes.
  • [0046]
    We define patterns that are used by the pattern matcher to extract data access logic from application programs. The data access patterns (301) are expressed as a combination of primitive data operations (302) on a data entity (303) search (304), create (309), update (311) and delete (310) operation. The search operation is further classified into two types—controlling operation (locate or position) (305) and dependent operation (retrieve) (306). The search operations additionally contain specifications that make use of fields, for search criteria (308) and search results (307). Each data access pattern can have parameters that form input to the data access operation.
  • [0047]
    A data access pattern (301) consists of one or more such primitive operations (302) and a set of parameters that are expressed as fields. The order and combination of such primitive data operations determine a unique data access pattern.
  • [0048]
    Some examples of data access patterns are: check existence of a customer (locate), find all customers belonging to a particular region (locate+multiple retrieval) and retrieve billing details of a particular customer (locate+single retrieval).
  • [0049]
    Based on the specifications, different instances of the data access patterns are extracted.
  • Data Entity Identification
  • [0050]
    In a program, data entities are used to hold data values. Each data entity has a data type that determines the kind of data values that the entity can hold.
  • [0051]
    Legacy systems can be programmed using many possible platforms and programming languages. Elementary types like integer, float, character, string and boolean are common in many programming languages. However, the ways these types are specified and behave during runtime are different across languages or platforms. Composite types like structures and unions are also similar. Abstract data types like classes and objects are found in modern object oriented languages like C++ and Java. We identify data entities in legacy applications such that these entities hold a certain type of values. The type of values may be decided based on the usage of the data entity. The entities may be elementary or of composite type.
  • [0052]
    We define patterns to extract types of data entities from legacy applications. Elementary data types—integer, float and character are discovered based on the size of the entity. A boolean type is identified when a variable is assigned only one constant value in the program or the entity is used in condition expressions and simple assignments.
  • [0053]
    String type may be fixed-length or variable-length. Our pattern defines the type of such data entities based on the usage context. Composite types (called as record or structure in legacy programming languages) are also defined as data entities. The data entities are identified using the entity pattern matcher.
  • Domain Entity
  • [0054]
    An application usually accesses many data stores (example is database table) to complete its assigned task. One of the data store units that is primary to the functionality of the application is considered as the domain of the application. This is an external input provided to the re-architecting method. Such a composite type is defined as Domain entity.
  • [0055]
    Domain entity pattern is conceptualized to hold the computations and validations. It is used by services. Each program in the source legacy system has an associated domain entity which is provided as an external input to the system. We use program analysis to find out hops in program that transfer the data values from screen to the data store. For each hop, we define a domain object whose type is the corresponding domain class. The program variables participating in the hop map to the attributes of the domain object.
  • Service Entity
  • [0056]
    Service entity pattern is conceptualized to hold the services. The above entities are defined for re-architecting but the invention does not restrict the target architecture to have only these entities but provides flexibility to define as many types of entities as deemed appropriate and define appropriate patterns to identify the instances in the legacy system.
  • User Interface
  • [0057]
    User Interface definition is a pattern that includes user interface definition to paint variety of controls on the screen. All interactive software systems have methods to define the screen layout and different types of controls to be placed on screen. This information is captured in User Interface definition pattern. It is a well known pattern and is easily identifiable through knowledge of interface provided by programming language to the user interface.
  • User Message
  • [0058]
    User Message is a pattern that includes message to be communicated between screen and business logic. All online applications have methods to specify fields on the screen. This information is captured in User Message pattern. It is a well known pattern and is easily identifiable through knowledge of interface provided by programming language to the user interface. We define a pattern to capture the composite type of the screen-layout as a message-collection class to help communicate between the screens and the programs.
  • Data Definition
  • [0059]
    The Data Definition pattern defines the layout of persistent data containing layout of information in persistent storage, such as a relational database. This pattern is used to identify the persistent data entities, fields in the persistent data entity and the keys. It is a well known pattern and is easily identifiable through knowledge of interface between programming language and data store elements.
  • [0060]
    The computation pattern is defined based on the rule of elimination of other patterns.
  • [0061]
    All the above described patterns are extracted using the pattern matcher tool generated using the specification-driven workbench and stored in a repository.
  • Optimization of Pattern Instances
  • [0062]
    The extracted pattern instances—validations, services, user interface, data access and data definitions are optimized for the selected target architecture. This step provides the flexibility to customize the pattern instances before runtime components are generated for the target architecture.
  • [0063]
    Optimization includes but is not limited to the following steps:
  • [0064]
    Validations: Modify error messages, modify screen field association, modify domain association and remove duplicates
  • [0065]
    Service workflow: Reuse existing service and refine service workflow Domain Entity: Add, modify and rename domain attributes
  • [0066]
    Data access: Modify search criteria, modify search result definition
  • [0067]
    User interface: Modify screen field attributes, modify screen display attributes and change action mappings (service association)
  • [0068]
    Data definitions: Rename persistent field and change field definitions The optimization step enables better control over the re-architecting process and improved quality of re-architected output due to better reuse of business logic across applications. Carrying out the optimization steps at the pattern instance level ensures better efficiency in the transformation process when compared to refactoring of runtime components (code level refactoring).
  • Conversion & Generation
  • [0069]
    Conversion & generation step involves generation of runtime components from optimized pattern instances for the target architecture.
  • [0070]
    Since the re-architected system is built using the object-oriented language it is important to identify relevant classes with appropriate class members which lay the foundation of the target system. Target architecture definition plays a vital role in defining the classes that should be there in the target system, though identification of these classes is done through data entity pattern matching in the source legacy system.
  • [0071]
    Classes are generated from the data entities used by the legacy system. Domain classes are generated from domain entities and service classes are generated from service entities. Message classes are generated from user message pattern to hold the data that is communicated between user interface and business logic. Persistent classes are generated from data definition pattern which are utilities to persist information in data store. Data access classes are generated from data access pattern which are utilities to interact with data stores. The data access operations are generated using SQL standards.
  • [0072]
    Class member types are converted from legacy language to object oriented language. To map the different types in legacy language which are not available in object oriented language, we introduce abstract data types in object oriented language. A library of abstract data type is created which is used during execution so that the behavior of the legacy system can be simulated in the target system.
  • [0073]
    Objects are instance of classes. Code for instantiation of objects (domain, services, user message etc.) is generated at locations closest to their first use by making use of the information given by data flow analysis. Data flow analysis is used to compute the parameters of the methods. Data-flow analysis is also used to determine variables and objects that are accessed across services and such variables are then stored and fetched from temporary data areas accessible across services. Calls to methods are introduced so that the functionality in the re-architected system is achieved.
  • [0074]
    The core business logic is encapsulated in domain class. The computations and validations are converted into different methods that are added to the appropriate domain class. In this way, domain class is constructed with attributes of the business domain as well as validation and computation methods extracted from legacy system. Based on the call hierarchy, we mark the access modifier of methods as ‘private’ or ‘public’.
  • [0075]
    The services workflow information is externalized so that the services can be orchestrated using a generic engine. Service class provides the services by using methods of domain class.
  • [0076]
    Irrespective of the source legacy environment, target architecture can consist of distinct presentation, business logic and data access layers. The target architecture conforms to layered architecture such as MVC (Model View Controller). The user interfaces comprise the view. The service classes comprise the model. The controller orchestrates these services using the service workflow information to perform the user specified action.
  • Example
  • [0077]
    An example of AS/400 program written in RPG language has been taken to depict how the invented method leads to generation of a re-architected system of modern architecture as shown in FIG. 4.
  • [0078]
    In this example, the source application has presentation logic, business logic and data access logic all mixed up. The application module performs business function in a conversational mode. The application module populates data on screen, throws the screen to the user and waits for user input (conversational style). Once the user enters data on the screen the application module resumes control. It validates the user provided data. If the validation is successful, it continues to perform business calculation and updates the application database with the calculated values.
  • [0079]
    Using the described method, we can move from the code structure described above to separate the presentation layer from the core business and data access functionality. In the re-architected application for the above example, the application is separated into distinct layers. The screens (509) comprise the view. The application is broken into different services (model) and their workflow (orchestration) is externalized in a service workflow (508) XML. The controller (510) makes use of this XML and orchestrates different services to perform the user specified. In this example: one service is responsible for populating screen data (501), the second service is responsible for carrying out business validations (502), a third service is responsible for business calculation (503) and saving (504) the result to database (507). The service layer itself is a thin layer, which makes calls to methods in domain class (505) to implement the business logic. The methods in domain class (505) make calls to persistent classes to perform the data access operations, so that the domain class (505) is independent of underlying data store implementation. Any information that has to be persisted across services is shared through user session (506). User session (506) stores the current state of services for each user.
  • STATEMENT OF THE INVENTION
  • [0080]
    According to the present invention therefore the method of re-architecting legacy systems comprises conceptualizing the said system as a combination of plurality of pattern instances, defining patterns, specifying the said patterns into a workbench to generate plurality of pattern matchers, identifying plurality of instances of said patterns using said pattern matchers, optimizing the said instances, and transforming the said instances through conversion and generation using object-oriented language to form a re-architected system.
  • [0081]
    The patterns include, but not limiting to, services, validations, computation, data entities, data definition, data access, user interfaces and user messages.
  • [0082]
    The data entities include domain entities or service entities. These data entities are identified from the said legacy system. They are created based on domain information. The said entity is a domain entity. The service entities are created from the said legacy system. The said patterns are stored in a pattern repository, which is updated with the new patterns. The said specified patterns encompass programming language specifics and programming techniques of legacy system. The said validation pattern consists of checks on data entities that result into defined errors.
  • [0083]
    The said data access pattern consists of pre-defined sequence of native commands. The said pre-defined sequence is based on SQL (structured query language) standard.
  • [0084]
    The identified pattern instances are stored in an instance-repository, which is updated by optimization of the said pattern instances.
  • [0085]
    The said data entities generate classes in the object oriented language. These classes include domain classes and service classes. The said services, validations, computation are converted into methods of said classes using pre-defined mapping between legacy language and object oriented language.
  • [0086]
    The said computation and validation methods are added to said domain classes.
  • [0087]
    The said service methods are added to said service classes and the flow among the said service instances is identified.
  • [0088]
    The said data access, data definitions, user interfaces and user messages generate code in accordance with the re-architected system.
  • [0089]
    The legacy system is converted into layered architecture with distinct presentation, business logic and data access layers. According to the present invention, therefore it also comprises of a system of automated re-architecting of legacy systems comprising language specific parser, an analyzer, pattern matchers to identify pattern instances and converter and generator to transform the said pattern instances in the given order to form the re-architected system.
  • [0090]
    The said system performs the aforesaid method. The pattern matchers are generated by specifying the patterns into a workbench and are independent of programming languages. The said converter is generated by specifying the conversion rules into a workbench.
  • [0091]
    Detailed descriptions of the preferred embodiment are provided herein; however, it is to be understood that the present invention may be embodied in various forms. Therefore, specific details disclosed herein are not to be interpreted as limiting, but rather as a basis for the claims and as a representative basis for teaching one skilled in the art to employ the present invention in virtually any appropriately detailed system, structure or matter.
  • [0092]
    The embodiments of the invention as described above and the methods disclosed herein will suggest further modification and alternations to those skilled in the art. Such further modifications and alterations may be made without departing from the sprit and scope of the invention, which is defined by the scope of the following claims.
  • INDUSTRIAL APPLICATIONS
  • [0000]
      • 1. It provides method to modernize legacy applications to service-oriented architecture implemented using object oriented language
      • 2. It saves manpower and cost.
      • 3. It provides documentation of existing business applications
      • 4. It performs reverse engineering of applications to extract design It provides a web-based user interface to legacy systems
      • 5. It provides transformation of file operations in legacy languages to SQL
      • 6. It provides a flexible, cost effective solution enabling business to reduce maintenance cost, and dependency on scarce legacy skills
      • 7. The patterns to extract various abstractions are specified and not programmed.
      • 8. Variations in patterns can therefore be accommodated with ease.
      • 9. It is flexible to suit to changing modern needs.
      • 10. It is a very intellectual tool that brings about effective and efficient results.

Claims (28)

  1. 1. A method of re-architecting legacy systems comprising conceptualizing the said system as a combination of plurality of pattern instances, defining patterns, specifying the said patterns into a workbench to generate plurality of pattern matchers, identifying plurality of instances of said patterns using said pattern matchers, optimizing the said instances, and transforming the said instances through conversion and generation using object-oriented language to form a re-architected system.
  2. 2. A method of re-architecting legacy system as claimed in claim 1, wherein said patterns include, but not limiting to, services, validations, computation, data entities, data definition, data access, user interfaces and user messages.
  3. 3. A method of re-architecting legacy system as claimed in claim 1, wherein said data entities include domain entities or service entities.
  4. 4. A method of re-architecting legacy system as claimed in claim 2, wherein said patterns are stored in a pattern repository.
  5. 5. A method of re-architecting legacy system as claimed in claim 4, wherein said pattern repository is updated with the new patterns.
  6. 6. A method of re-architecting legacy system as claimed in claim 1, wherein said specified patterns encompass programming language specifics and programming techniques of legacy system.
  7. 7. A method of re-architecting legacy system as claimed in claim 2, wherein data entities are identified from the said legacy system.
  8. 8. The method of re-architecting of legacy systems as claimed in claim 2, wherein data entities are created based on domain information.
  9. 9. The method of re-architecting of legacy systems as claimed in claim 8, wherein the said entity is a domain entity.
  10. 10. A method of re-architecting legacy system as claimed in claim 2, wherein service entities are created from the said legacy system.
  11. 11. A method of re-architecting legacy system as claimed in claim 2, wherein said validation pattern consists of checks on data entities that result into defined errors.
  12. 12. A method of re-architecting legacy system as claimed in claim 2, wherein said data access pattern consists of pre-defined sequence of native commands.
  13. 13. A method of re-architecting legacy system as claimed in claim 12, wherein said pre-defined sequence is based on SQL (structured query language) standard.
  14. 14. The method of re-architecting of legacy systems as claimed in claim 1 wherein identified pattern instances are stored in an instance-repository.
  15. 15. The method of re-architecting of legacy systems as claimed in claim 14, wherein the said instance-repository is updated by optimization of the said pattern instances.
  16. 16. The method of re-architecting of legacy systems as claimed in claim 1 and claim 2 wherein the said data entities generate classes in the object oriented language.
  17. 17. The method of re-architecting of legacy systems as claimed in claim 16, wherein the said classes include domain classes and service classes.
  18. 18. The method of re-architecting of legacy systems as claimed in claims 2 and 16, wherein said services, validations, computation are converted into methods of said classes using pre-defined mapping between legacy language and object oriented language.
  19. 19. The method of re-architecting of legacy systems as claimed in claims 17 and 18, wherein the said computation and validation methods are added to said domain classes.
  20. 20. The method of re-architecting of legacy systems as claimed in claims 17 and 18, wherein the said service methods are added to said service classes.
  21. 21. The method of re-architecting of legacy systems as claimed in claim 2, wherein the flow among the said service instances is identified.
  22. 22. The method of re-architecting of legacy systems as claimed in claim 1 and claim 2 wherein said data access, data definitions, user interfaces and user messages generate code in accordance with the re-architected system.
  23. 23. The method of re-architecting of legacy systems as claimed in claim 1, wherein the legacy system is converted into layered architecture with distinct presentation, business logic and data access layers.
  24. 24. A System of automated re-architecting of legacy systems comprising language specific parser, an analyzer, pattern matchers to identify pattern instances and converter and generator to transform the said pattern instances in the given order to form the re-architected system.
  25. 25. A System of automated re-architecting of legacy systems that performs the method as claimed in claim 1.
  26. 26. A system as claimed in claim 24, wherein said pattern matchers are generated by specifying the patterns into a workbench.
  27. 27. A system as claimed in claim 24, wherein said pattern matchers are independent of programming languages.
  28. 28. A system as claimed in claim 24, wherein said converter is generated by specifying the conversion rules into a workbench.
US12298528 2006-04-26 2008-10-25 System and method for automated re-architectureing of legacy systems using object oriented language Active 2030-07-31 US8819621B2 (en)

Priority Applications (3)

Application Number Priority Date Filing Date Title
IN655/MUM/2006 2006-04-26
IN655MU2006 2006-04-26
PCT/IN2007/000170 WO2007122640A3 (en) 2006-04-26 2007-04-26 A system and method for automated re-architectureing of legacy systems using object-oriented language

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
PCT/IN2007/000170 Continuation WO2007122640A3 (en) 2006-04-26 2007-04-26 A system and method for automated re-architectureing of legacy systems using object-oriented language

Publications (3)

Publication Number Publication Date
US20100083221A1 true true US20100083221A1 (en) 2010-04-01
US20110035725A9 true US20110035725A9 (en) 2011-02-10
US8819621B2 US8819621B2 (en) 2014-08-26

Family

ID=38625424

Family Applications (1)

Application Number Title Priority Date Filing Date
US12298528 Active 2030-07-31 US8819621B2 (en) 2006-04-26 2008-10-25 System and method for automated re-architectureing of legacy systems using object oriented language

Country Status (3)

Country Link
US (1) US8819621B2 (en)
EP (1) EP2087424A4 (en)
WO (1) WO2007122640A3 (en)

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20100095282A1 (en) * 2008-10-10 2010-04-15 The Boeing Company Method, Apparatus And Computer Program Product For Creating Inter-Language Interface
US20110138350A1 (en) * 2006-04-26 2011-06-09 Tata Consultancy Services System and method for pattern based services extraction
US20150268955A1 (en) * 2014-03-24 2015-09-24 Tata Consultancy Services Limited System and method for extracting a business rule embedded in an application source code
US9367597B2 (en) 2013-11-18 2016-06-14 International Business Machines Corporation Automatically managing mapping and transform rules when synchronizing systems
US9542467B2 (en) 2013-11-18 2017-01-10 International Business Machines Corporation Efficiently firing mapping and transform rules during bidirectional synchronization

Families Citing this family (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR101371619B1 (en) * 2007-02-14 2014-03-06 삼성전자주식회사 Apparatus and method for componentizing legacy system
US8893074B2 (en) * 2011-03-11 2014-11-18 Hewlett-Packard Development Company, L.P. Software development requirements recording
US9110767B2 (en) 2012-07-09 2015-08-18 Accenture Global Services Limited Cobol reference architecture
US9916185B2 (en) 2014-03-18 2018-03-13 International Business Machines Corporation Managing processing associated with selected architectural facilities
US9582295B2 (en) 2014-03-18 2017-02-28 International Business Machines Corporation Architectural mode configuration
US9588774B2 (en) 2014-03-18 2017-03-07 International Business Machines Corporation Common boot sequence for control utility able to be initialized in multiple architectures

Citations (11)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6018627A (en) * 1997-09-22 2000-01-25 Unisys Corp. Tool-independent system for application building in an object oriented development environment with data stored in repository in OMG compliant UML representation
US6247172B1 (en) * 1998-07-02 2001-06-12 Hewlett-Packard Company Method for a translation system that aggressively optimizes and preserves full synchronous exception state
US6334215B1 (en) * 1999-05-05 2001-12-25 International Business Machines Corporation Methodology for migration of legacy applications to new product architectures
US6389385B1 (en) * 1999-07-02 2002-05-14 International Business Machines Corporation System and method for translating source code
US6389588B1 (en) * 1999-02-04 2002-05-14 Relativity Technologies Method and system of business rule extraction from existing applications for integration into new applications
US6453464B1 (en) * 1998-09-03 2002-09-17 Legacyj. Corp., Inc. Method and apparatus for converting COBOL to Java
US6467079B1 (en) * 1999-03-30 2002-10-15 International Business Machines Corporation Report program language source code translation to object-oriented language source code which emulates report program language behavior
US20030074648A1 (en) * 2001-09-28 2003-04-17 Michel Brassard System and method for managing architectural layers within a software model
US20040158820A1 (en) * 2003-02-11 2004-08-12 Moore John Wesley System for generating an application framework and components
US20050138603A1 (en) * 2003-12-22 2005-06-23 Cha Jung E. Componentization method for reengineering legacy system
US20060265696A1 (en) * 2005-05-23 2006-11-23 International Business Machines Corporation Method and system for data migration between versions of software

Patent Citations (11)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6018627A (en) * 1997-09-22 2000-01-25 Unisys Corp. Tool-independent system for application building in an object oriented development environment with data stored in repository in OMG compliant UML representation
US6247172B1 (en) * 1998-07-02 2001-06-12 Hewlett-Packard Company Method for a translation system that aggressively optimizes and preserves full synchronous exception state
US6453464B1 (en) * 1998-09-03 2002-09-17 Legacyj. Corp., Inc. Method and apparatus for converting COBOL to Java
US6389588B1 (en) * 1999-02-04 2002-05-14 Relativity Technologies Method and system of business rule extraction from existing applications for integration into new applications
US6467079B1 (en) * 1999-03-30 2002-10-15 International Business Machines Corporation Report program language source code translation to object-oriented language source code which emulates report program language behavior
US6334215B1 (en) * 1999-05-05 2001-12-25 International Business Machines Corporation Methodology for migration of legacy applications to new product architectures
US6389385B1 (en) * 1999-07-02 2002-05-14 International Business Machines Corporation System and method for translating source code
US20030074648A1 (en) * 2001-09-28 2003-04-17 Michel Brassard System and method for managing architectural layers within a software model
US20040158820A1 (en) * 2003-02-11 2004-08-12 Moore John Wesley System for generating an application framework and components
US20050138603A1 (en) * 2003-12-22 2005-06-23 Cha Jung E. Componentization method for reengineering legacy system
US20060265696A1 (en) * 2005-05-23 2006-11-23 International Business Machines Corporation Method and system for data migration between versions of software

Cited By (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20110138350A1 (en) * 2006-04-26 2011-06-09 Tata Consultancy Services System and method for pattern based services extraction
US9612829B2 (en) * 2006-04-26 2017-04-04 Tata Consultancy Services System and method for pattern based services extraction
US20100095282A1 (en) * 2008-10-10 2010-04-15 The Boeing Company Method, Apparatus And Computer Program Product For Creating Inter-Language Interface
US8533689B2 (en) * 2008-10-10 2013-09-10 The Boeing Company Method, apparatus and computer program product for creating inter-language interface
US9367597B2 (en) 2013-11-18 2016-06-14 International Business Machines Corporation Automatically managing mapping and transform rules when synchronizing systems
US9519700B2 (en) 2013-11-18 2016-12-13 International Business Machines Corporation Automatically synchronizing production data of a source system and a target system
US9542467B2 (en) 2013-11-18 2017-01-10 International Business Machines Corporation Efficiently firing mapping and transform rules during bidirectional synchronization
US20150268955A1 (en) * 2014-03-24 2015-09-24 Tata Consultancy Services Limited System and method for extracting a business rule embedded in an application source code
US9875098B2 (en) * 2014-03-24 2018-01-23 Tata Consultancy Services Limited System and method for extracting a business rule embedded in an application source code

Also Published As

Publication number Publication date Type
EP2087424A2 (en) 2009-08-12 application
EP2087424A4 (en) 2009-12-23 application
US8819621B2 (en) 2014-08-26 grant
WO2007122640A3 (en) 2009-04-16 application
US20110035725A9 (en) 2011-02-10 application
WO2007122640A2 (en) 2007-11-01 application

Similar Documents

Publication Publication Date Title
Bauer et al. Java Persistance with Hibernate
Seacord et al. Modernizing legacy systems: software technologies, engineering processes, and business practices
Jouault et al. Transforming models with ATL
Kalnins et al. Model transformation language MOLA
Agrawal et al. Graph transformations on domain-specific models
Ermel et al. The AGG approach: Language and environment
US7047518B2 (en) System for software application development and modeling
Biermann et al. Graphical definition of in-place transformations in the eclipse modeling framework
US5873094A (en) Method and apparatus for automated conformance and enforcement of behavior in application processing systems
US6571247B1 (en) Object oriented technology analysis and design supporting method
US7032210B2 (en) Method and system for generating program source code of a computer application from an information model
Nagl Building tightly integrated software development environments: the IPSEN approach
Wimmer et al. Towards model transformation generation by-example
US6701381B2 (en) Data processing system and development method
Van Den Brand et al. Term rewriting with traversal functions
US20080134138A1 (en) Producer graph oriented programming and execution
US6151608A (en) Method and system for migrating data
US5550971A (en) Method and system for generating a user interface adaptable to various database management systems
US20080082959A1 (en) Data processing system and method
Ambriola et al. Assessing process-centered software engineering environments
Bodart et al. Towards a systematic building of software architecture: The TRIDENT methodological guide
US5930806A (en) Method and system for data migration from network database to relational database
US20050108684A1 (en) Method and system for generating an application object repository from application framework metadata
US20070179939A1 (en) System and method for automatic data mapping
Del Fabro et al. Towards the efficient development of model transformations using model weaving and matching transformations

Legal Events

Date Code Title Description
AS Assignment

Owner name: TATA CONSULTANCY SERVICES,INDIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:NAIK, RAVINDRA, MR.;SAXENA, AMIT, MR.;RAMASWAMI, NARAYAN, MR.;AND OTHERS;REEL/FRAME:023297/0743

Effective date: 20090622

Owner name: TATA CONSULTANCY SERVICES, INDIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:NAIK, RAVINDRA, MR.;SAXENA, AMIT, MR.;RAMASWAMI, NARAYAN, MR.;AND OTHERS;REEL/FRAME:023297/0743

Effective date: 20090622

MAFP

Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1551)

Year of fee payment: 4