FORM 2
THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENT RULES, 2003
COMPLETE SPECIFICATION
(See Section 10 and Rule 13)
Title of invention:
METHOD AND SYSTEM FOR TECHNOLOGY AGNOSTIC LEGACY
APPLICATION TRANSFORMATION USING MODEL DRIVEN
APPROACH
Applicant
Tata Consultancy Services Limited
A company Incorporated in India under the Companies Act, 1956
Having address:
Nirmal Building, 9th floor,
Nariman point, Mumbai 400021,
Maharashtra, India
Preamble to the description:
The following specification particularly describes the invention and the
manner in which it is to be performed.
2
CROSS-REFERENCE TO RELATED APPLICATIONS AND PRIORITY
[001] The present application claims priority from Indian provisional
application no. 202021043520, filed on October 06, 2020. The entire contents of
the aforementioned application are incorporated herein by reference.
5
TECHNICAL FIELD
[002] The disclosure herein generally relates to the field of legacy
application transformation and more particularly, method and system for
technology agnostic legacy application transformation using model driven
10 approach.
BACKGROUND
[003] Legacy applications are applications which are large, monolithic,
and difficult to modify. These applications are considered obsolete, or that is based
15 on technology that is older than a current standard. Legacy transformation is the
process of modernizing an operational system to retain and extend the value of
investments in that system. Scrapping or replacing the legacy applications often
means reengineering an organization's business processes as well.
[004] Millions of applications are still running in the legacy environment.
20 Understanding and modifying the codes of these legacy applications is a common
problem most of the customers are facing in real time. Support for a legacy
application is difficult due to skill gaps, technology and infrastructure
advancement. There is a tight dependency of legacy applications with platform and
technology-specific libraries. Further, there are also financial and operational
25 challenges in incorporating security-related enhancements in the legacy
application code. In addition to that, there is also a maintenance overhead to run
the legacy applications in production environment.
[005] Legacy application modernization is a manual, and sometimes
semi-automated activity which is often time and effort consuming. Hence, it is
30 often subject to human error. This process requires teams and subject matter
experts (SMEs), who are highly skilled in legacy as well as modern technologies
3
which also is a big challenge. The current IT technology is changing very rapidly
such that the applications which were developed three years ago are now
considered legacy. Continuous modernization is necessary to stay relevant in
today’s market due to the dynamic technology landscape.
5
SUMMARY
[006] Embodiments of the present disclosure present technological
improvements as solutions to one or more of the above-mentioned technical
problems recognized by the inventors in conventional systems. For example, in
10 one embodiment, a system for analyzing a plurality of data streams in real time is
provided. The system comprises an input/ output interface, one or more hardware
processors and a memory. The input/ output interface configured to provide a
legacy application code as an input, wherein the legacy application code is written
in a source language. The a memory is in communication with the one or more
15 hardware processors, wherein the one or more first hardware processors are
configured to execute programmed instructions stored in the memory to: parse the
legacy application code using a parser; split the parsed legacy application code
based on an application tier, wherein an output of the splitting is in extensible
markup language (XML) specifications; create an intermediate model for a
20 plurality of functionalities in the legacy code using the XML specifications
comprising relevant business logic; generate a second intermediate model from the
first intermediate model using a model creator to make the legacy code as
technology independent, wherein the second intermediate model comprises a
plurality of technology independent models corresponding to functionalities
25 present in the code; select a target technology stack by the user; generate a
scaffolding code for the target technology stack selected by the user; map syntax
of the source language of the legacy application code to the language of the target
technology stack using a code transformation unit to obtain a transformed business
logic; generate a technology specific code corresponding to the target application
30 based on the second intermediate model and the transformed business logic using
4
a code generator; and package and deploy the technology specific code into a
format applicable for one of a cloud or traditional deployment environment.
[007] In another aspect, a method for transformation of a legacy
application code is provided. Initially, a legacy application code is provided as an
5 input, wherein the legacy application code is written in a source language. The
legacy application code is then parsed using a parser. Further, the parsed legacy
application code is split based on an application tier, wherein an output of the
splitting is in extensible markup language (XML) specifications. In the next step,
an intermediate model is created for a plurality of functionalities in the legacy code
10 using the XML specifications comprising relevant business logic. In the next step,
a second intermediate model is generated from the first intermediate model using
a model creator to make the legacy code as technology independent, wherein the
second intermediate model comprises a plurality of technology independent
models corresponding to the plurality of functionalities present in the legacy code.
15 Further, a target technology stack is selected by the user. A scaffolding code is then
generated for the target technology stack selected by the user. In the next step,
syntax of the source language of the legacy application code is mapped to the
language of the target technology stack using a code transformation unit to obtain
a transformed business logic. Further, a technology specific code is generated
20 corresponding to the target application based on the second intermediate model and
the transformed business logic using a code generator. And finally, the technology
specific code is packaged and deployed into a format applicable for one of a cloud
or traditional deployment environment.
[008] In yet another aspect, one or more non-transitory machine readable
25 information storage mediums comprising one or more instructions which when
executed by one or more hardware processors cause transformation of a legacy
application code. Initially, a legacy application code is provided as an input,
wherein the legacy application code is written in a source language. The legacy
application code is then parsed using a parser. Further, the parsed legacy
30 application code is split based on an application tier, wherein an output of the
splitting is in extensible markup language (XML) specifications. In the next step,
5
an intermediate model is created for a plurality of functionalities in the legacy code
using the XML specifications comprising relevant business logic. In the next step,
a second intermediate model is generated from the first intermediate model using
a model creator to make the legacy code as technology independent, wherein the
5 second intermediate model comprises a plurality of technology independent
models corresponding to the plurality of functionalities present in the legacy code.
Further, a target technology stack is selected by the user. A scaffolding code is then
generated for the target technology stack selected by the user. In the next step,
syntax of the source language of the legacy application code is mapped to the
10 language of the target technology stack using a code transformation unit to obtain
a transformed business logic. Further, a technology specific code is generated
corresponding to the target application based on the second intermediate model and
the transformed business logic using a code generator. And finally, the technology
specific code is packaged and deployed into a format applicable for one of a cloud
15 or traditional deployment environment.
[009] It is to be understood that both the foregoing general description and
the following detailed description are exemplary and explanatory only and are not
restrictive of the invention, as claimed.
20 BRIEF DESCRIPTION OF THE DRAWINGS
[010] The accompanying drawings, which are incorporated in and
constitute a part of this disclosure, illustrate exemplary embodiments and, together
with the description, serve to explain the disclosed principles:
[011] FIG. 1 illustrates a network diagram of a system for transformation
25 of a legacy application code according to some embodiments of the present
disclosure.
[012] FIG. 2 is a functional block diagram of the system for
transformation of a legacy application code according to some embodiments of the
present disclosure.
6
[013] FIG. 3 is a flow diagram illustrating a method for transformation of
a legacy application code in accordance with some embodiments of the present
disclosure.
5 DETAILED DESCRIPTION OF EMBODIMENTS
[014] Exemplary embodiments are described with reference to the
accompanying drawings. In the figures, the left-most digit(s) of a reference number
identifies the figure in which the reference number first appears. Wherever
convenient, the same reference numbers are used throughout the drawings to refer
10 to the same or like parts. While examples and features of disclosed principles are
described herein, modifications, adaptations, and other implementations are
possible without departing from the scope of the disclosed embodiments.
[015] Legacy transformation is the process of modernizing an operational
system to retain and extend the value of investments in that system. Millions of
15 applications are still running in the legacy environment. Understanding and
modifying the codes of these legacy applications is a common problem most of the
customers are facing in real time. Support for a legacy application is difficult due
to skill gaps, technology and infrastructure advancement.
[016] Left-shift approach is most commonly followed approach for
20 legacy transformation which needs several iterations of design refinement,
regression testing and quality checks. Few manual methods and automated
methods also exist in the prior art for the transformation of legacy applications.
These are time-consuming processes and seriously affect the time to market. These
methods involve heavy costs and high time during modernization of legacy
25 applications. Moreover, there are quality issues in developing modern application
based on the legacy code. There are also challenges in incorporating ongoing
technology upgrades into the modernization journey.
[017] The embodiments herein provide method and system for
technology agnostic legacy application transformation using model driven
30 approach. The method proposes to transform an existing legacy application code
into a target application code mentioned by a user. The disclosed method analyzes
7
and parses the legacy application code. Further, the method extracts the details of
the legacy application code into an intermediate model which is technology
independent. The business logic and semantics of the legacy application are
extracted for further processing. A code is generated corresponding to the target
5 application based on the technology independent intermediate model and the
business logic of the legacy application. The method proposes legacy application
transformation into a required technology as per user’s needs based on technology
agnostic models. The final target application code is packaged into a format which
is suitable for traditional or cloud-native deployment environment along with all
10 the required reports and documentation. The generated code complies with NFR
standard like security, performance and legal requirements.
[018] Referring now to the drawings, and more particularly to FIG. 1
through FIG. 3, where similar reference characters denote corresponding features
consistently throughout the figures, there are shown preferred embodiments and
15 these embodiments are described in the context of the following exemplary system
and/or method.
[019] FIG. 1 illustrates a network diagram of a system 100 for
transformation of a legacy application code using a model driven approach. A
block diagram of the system 100 for transformation of a legacy application code is
20 shown in FIG. 2. Although the present disclosure is explained considering that the
system 100 is implemented on a server, it may also be present elsewhere such as a
local machine. It may be understood that the system 100 comprises one or more
computing devices 102, such as a laptop computer, a desktop computer, a
notebook, a workstation, a cloud-based computing environment and the like. It will
25 be understood that the system 100 may be accessed through one or more
input/output interfaces 104-1, 104-2... 104-N, collectively referred to as I/O
interface 104. Examples of the I/O interface 104 may include, but are not limited
to, a user interface, a portable computer, a personal digital assistant, a handheld
device, a smartphone, a tablet computer, a workstation and the like. The I/O
30 interface 104 are communicatively coupled to the system 100 through a network
106.
8
[020] In an embodiment, the network 106 may be a wireless or a wired
network, or a combination thereof. In an example, the network 106 can be
implemented as a computer network, as one of the different types of networks, such
as virtual private network (VPN), intranet, local area network (LAN), wide area
5 network (WAN), the internet, and such. The network 106 may either be a dedicated
network or a shared network, which represents an association of the different types
of networks that use a variety of protocols, for example, Hypertext Transfer
Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), and
Wireless Application Protocol (WAP), to communicate with each other. Further,
10 the network 106 may include a variety of network devices, including routers,
bridges, servers, computing devices, storage devices. The network devices within
the network 106 may interact with the system 100 through communication links.
[021] The system 100 may be implemented in a workstation, a mainframe
computer, a server, and a network server. In an embodiment, the computing device
15 102 further comprises one or more hardware processors 108, one or more memory
110, hereinafter referred as a memory 110 and a data repository 112, for example,
a repository 112. The memory 110 is in communication with the one or more
hardware processors 108, wherein the one or more hardware processors 108 are
configured to execute programmed instructions stored in the memory 110, to
20 perform various functions as explained in the later part of the disclosure. The
repository 112 may store data processed, received, and generated by the system
100.
[022] The system 100 supports various connectivity options such as
BLUETOOTH®, USB, ZigBee and other cellular services. The network
25 environment enables connection of various components of the system 100 using
any communication link including Internet, WAN, MAN, and so on. In an
exemplary embodiment, the system 100 is implemented to operate as a stand-alone
device. In another embodiment, the system 100 may be implemented to work as a
loosely coupled device to a smart computing environment. The components and
30 functionalities of the system 100 are described further in detail.
9
[023] According to an embodiment of the disclosure, the memory 110
further comprises a plurality of units. The plurality of units is configured to perform
various functions. The plurality of units comprises a parser 114, an analysis unit
116, a model creator 118, a configurator 120, a code transformation unit 122, a
5 code generator 124, and a packaging and deployment unit 126.
[024] According to an embodiment of the disclosure, the input/output
interface 104 is configured to receive a legacy application code as input for
transforming into a target application. The legacy application code is written in a
source language. The legacy application code is provided to the parser 114 and
10 based on the type of technology of the existing application code, the parser 114 is
configured to parse the legacy application code to perform static code analysis. The
parsed legacy application code is further split based on an application tier. The
output of the splitting is in extensible markup language (XML) specifications.
Every application comprises a minimum of three layers or tiers, which is referred
15 to as the application tier. In an example, the application tier comprises a user
interface, service layer and a database.
[025] According to an embodiment of the disclosure, the analysis unit 116
is configured generate a first intermediate model of the legacy application code and
stores in the data repository 112. The first intermediate model is created for a
20 plurality of functionalities in the legacy application code using the XML
specifications comprising relevant business logic.
[026] The first intermediate model is generated based on a knowledge
model. The first intermediate model is a declarative representation of the legacy
application code in the form of model with relationship between User Interface
25 Screens, Event Handlers, Services, RESTful APIs, Classes, Entities, Data Transfer
Objects, Value Objects and so on. These elements are organized into corresponding
layers, where each layer represents a certain application tier or a mapping between
tiers. The first intermediate model also represents any meta-data that represents
any cross-cutting concern or configuration of the specifications for each of the
30 layers. The different layers in the first intermediate model and the mapping
between them is explained below.
10
[027] The different layers of the first intermediate model are UI layer,
UI-controller mapping layer, business layer, API/controller layer, object layer for
example, Plain Old Java Object (POJO) layer in case if the target language is Java
, Data Access Object-Object mapping layer for example DAO-POJO mapping
5 layer incase if target language is Java and DAO layer. The UI layer represents the
front end of the existing application. The analysis unit 116 generates the UI layer
specification from the knowledge model, which includes the list of user interface
screens, layout of the user interface controls in the screens, events triggered by
different elements in screens, data types associated to fields in the screen. The UI10 controller mapping layer contains mapping between services and screens, events
in screens that trigger those services, details of the data passed from each screen to
the API/controller layer. The API/controller layer is the interfacing layer between
UI and server side and contains the details of APIs consumed by the UI layer or
other application modules. This includes API signatures, parameters, type of API,
15 details of business logic for the controller APIs and references to any other
elements. The business layer includes details of classes that hold the business
operations, the business logic inside the business operations and references to any
other elements in the same or other layers. The business logic represents pieces of
code that carry out the desired functionality the existing application should carry
20 out. The existing application may contain standard database access or file access
code modules. The parser 114 parses these code modules and generates a generic
DAO layer specification inside the knowledge model. From the knowledge model,
a declarative specification for Data Access Objects, Entities, Entity-Mappings,
Keys, Indexes, Views and Queries that carry out data manipulation and retrieval
25 operations from the existing application database is generated. The analysis unit
116 reads the datatypes present in the existing application code and creates generic
data types. When the input classes are legacy data types, some type conversion is
required, such as byte operations. The object layer contains details of such
conversions in a declarative manner. The code generator uses these details to
30 generate the corresponding code. The object layer also includes the data transfer
objects, which pass the data between the above layers. The DAO-object mapping
11
layer includes mappings between the DAO objects and data transfer objects. This
layer also contains meta-data for any utility methods to be included for data
transformation between the DAO and object layers. The configuration layer is the
key layer in the first intermediate model. This layer contains declarative
5 specifications about the different aspects of the remaining layers. This includes the
following:
(i) Structure and organization of the layers
(ii) Naming conventions required in code generation
(iii) Technology choices and configuration for the code generator and
10 the code transformation modules
(iv) Configurations of elements in different layers
(v) Meta-data to handle data in different layers
(vi) Details of any third-party utilities or libraries required
[028] According to an embodiment of the disclosure, business logic
15 extraction provides all technical rules embedded in the existing application. The
business logic is translated, classified and rationalized and use case documents are
further created. Reverse engineering business logic include two key steps: rule
extraction and rule review. Rule Extraction maps the technical rules extracted and
provides a common template to define all the technical rules and associated
20 parameters which help in segregation and classification of mapped rules. Rule
review maps the rules in a form independent of the technology and thereby will
facilitate classification, rationalization and extraction of the relevant rules that are
needed for forward engineering. These extracted rules also can be used as a
reference for customizing the standard business processes in commercial off-the25 shelf (COTS) products so that the application’s critical business processes are also
retained.
[029] According to an embodiment of the disclosure, the model creator
118 is configured to generate a second intermediate model from the first
intermediate model to make the legacy code as technology independent, wherein
30 the second intermediate model comprises a plurality of technology independent
models corresponding to functionalities present in the code. The model creator 118
12
contains a model repository and a modeler (not shown in the figures). The model
repository consists of one or more application models. The modeler is a tool that
facilitates creation of application models. The first intermediate model contains flat
files representing layered models. Each type of files is organized into their own
5 directory as per a predefined structure as specified in the configuration layer. These
flat files may have inter-dependencies. For example, if target language is java then
the Representational State Transfer (REST) service uses POJO classes as input and
output. Reference to the POJO class is present in the controller layer while the
actual POJO is present in the POJO layer. A flat file may also reference a text file
10 in a relative directory containing business logic.
[030] The model creator 118 takes the configuration from the
configuration layer and the first intermediate model. It validates these inputs and
if they are consistent, it creates the second intermediate model. The model creator
118 is intelligent enough to parse each flat file based on its type and create the
15 corresponding model elements in the model repository, based on a pre-defined
order to resolve all dependencies properly. For example, since UI layer is
dependent on the controller layer, flat files containing REST controller
specifications are parsed before UI layer files. The result of the parsing process is
a complete and consistent application model consisting of one or more
20 components.
[031] The second intermediate model is the output of the model creator
118. This is a refined version of the first intermediate model modified as per the
configuration layer and any user inputs. The second intermediate model stores the
information in technology independent models with all the relationship extracted
25 associated relates as per the source language. The second intermediate model is
complaint to Object Modelling Group (OMG) standards as UML 2.0 models. This
model is in a format understandable by the code generator 124. This primarily
contains models categorized into two broad categories front-end models and backend models. The front-end models encapsulate UI layer, UI Controller mappings.
30 Back-end models encapsulate all the remaining layers.
13
[032] According to an embodiment of the disclosure, the system 100 is
further configured to generate a scaffolding code for a target technology stack
selected by the user, wherein the scaffolding code is configured to be served as a
placeholder.
5 [033] According to an embodiment of the disclosure, the code
transformation unit 122 is configured to map syntax of the source language of the
legacy application code to the language of the target technology stack to obtain a
transformed business logic.
[034] The transformed business logic is populated under user defined
10 code tag and the snippet will be passed through the code transformation unit 122
to convert the legacy application code in the selected target technology
corresponding to a target application. During this process the transformed code is
translated to multiple layers based on the source business code. The code
transformation unit 122 takes the source language application components, reads
15 the programs present in these components and maps the syntax of these programs
from the source language of the existing application code to the target language
corresponding to the target application. Syntax primarily includes business logic
and data fields and any component dependencies. Each and every syntax is
converted into to equivalent target syntax. During conversion, dependent
20 components are also converted to single or multiple layers if necessary. Conversion
strategy for the sub components is specific to the technology. For example,
transforming procedural to object-oriented architecture.
[035] According to an embodiment of the disclosure, the code generator
124 is configured to generate a technology specific code corresponding to the target
25 application based on the second intermediate model and the transformed business
logic. The code generator 124 generates technology-specific code based on the
second intermediate model. The code generator 124 performs two important tasks:
(i) generation of project structure, the scaffolding code, any technology specific
configuration and (ii) weaving the transformed business logic into the generated
30 code. The first task involves generating application project structure and code
inside these structures as per each of the first intermediate model layers. The code
14
generator 124 also generates placeholders for business logic inside the generated
scaffolding, wherever applicable based on the second intermediate model. Once
code generation is complete, it weaves the business logic as per the placeholders
into the scaffolding, resulting in a completely transformed application code
5 organized into one or more projects.
[036] According to an embodiment of the disclosure, the configurator 120
helps the user to customize the generated patterns as per their needs. The tasks
performed by the configurator 120 are explained below. The configurator 120
contains a visual editor, which can perform a variety of tasks, which include:
10 • Edit the configuration layer and specify any additional configuration
for the model creator 118 and the code generator 124.
• Specify custom rules to analyze the input and perform parsing on
selected elements of the input existing application code.
• Configure the modeler as to how to interpret the mappings between the
15 different layers.
• Configure the code generator 124 as to how to interpret the model to
generate code.
• Perform any custom pre or post processing for the model creator 118
and the code generator 124.
20 [037] According to an embodiment of the disclosure, the packaging and
deployment unit 126 is configured to package and deploy the technology specific
code into a format applicable for one of a cloud or traditional deployment
environment. The packaging and deployment unit 126 compiles the application
projects and packages them into a deployable unit of user’s choice. Further it
25 deploys the deployable technology specific source code into the target application
runtime environment. Examples of target runtime environment are Cloud native,
Mobile etc.
[038] FIG. 3 illustrates an example flow chart of a method 300 system for
analyzing a plurality of data streams in real time, in accordance with an example
30 embodiment of the present disclosure. The method 300 depicted in the flow chart
15
may be executed by a system, for example, the system 100 of FIG. 1. In an example
embodiment, the system 100 may be embodied in a computing device.
[039] Operations of the flowchart, and combinations of operations in the
flowchart, may be implemented by various means, such as hardware, firmware,
5 processor, circuitry and/or other device associated with execution of software
including one or more computer program instructions. For example, one or more
of the procedures described in various embodiments may be embodied by
computer program instructions. In an example embodiment, the computer program
instructions, which embody the procedures, described in various embodiments may
10 be stored by at least one memory device of a system and executed by at least one
processor in the system. Any such computer program instructions may be loaded
onto a computer or other programmable system (for example, hardware) to produce
a machine, such that the resulting computer or other programmable system embody
means for implementing the operations specified in the flowchart. It will be noted
15 herein that the operations of the method 300 are described with help of system 100.
However, the operations of the method 300 can be described and/or practiced by
using any other system.
[040] Initially at step 302 of the method 300 a legacy application code is
provided as an input, wherein the legacy application code is written in a source
20 language. At step 304, the legacy application code is then parsed using a parser
114.
[041] Further at step 306 of the method 300, the parsed legacy application
code is split based on the application tier. The output of the splitting is in extensible
markup language (XML) specifications. At step 308, the intermediate model is
25 created for a plurality of functionalities in the legacy code using the XML
specifications comprising relevant business logic.
[042] Further at step 310 of the method 300, the second intermediate
model is generated from the first intermediate model using the model creator 118
to make the legacy code as technology independent. The second intermediate
30 model comprises a plurality of technology independent models corresponding to
16
the plurality of functionalities present in the legacy code. At step 312, a target
technology stack is selected by the user.
[043] At step 314 of the method 300, the scaffolding code is generated for
the target technology stack selected by the user. In the next step 316, the syntax of
5 the source language of the legacy application code is mapped to the language of
the target technology stack using the code transformation unit 122 to obtain a
transformed business logic. At step 318, a technology specific code is generated
corresponding to the target application based on the second intermediate model and
the transformed business logic using a code generator. And finally, at step 320, the
10 technology specific code is packaged and deployed into a format applicable for one
of a cloud or traditional deployment environment.
[044] The method disclosed automatically extracts the business logic and
specifications from legacy applications and their categorization into a technology
independent second intermediate model. The business logic and specifications are
15 categorized into different layers in the second intermediate model. Further the
second intermediate model is used for generating code corresponding to the target
application. Code transformation techniques are leveraged to transform legacy
business logic into the selected target technology specified by the user. The
generated code complies with Non-Functional requirement (NFR) standard like
20 security, performance and legal requirements.
[045] The written description describes the subject matter herein to enable
any person skilled in the art to make and use the embodiments. The scope of the
subject matter embodiments is defined by the claims and may include other
modifications that occur to those skilled in the art. Such other modifications are
25 intended to be within the scope of the claims if they have similar elements that do
not differ from the literal language of the claims or if they include equivalent
elements with insubstantial differences from the literal language of the claims.
[046] The embodiments of present disclosure herein address unresolved
problem of high cost, high time and quality issues involved in the legacy
30 transformation. The embodiment thus provides a method and system for
transformation of a legacy application code using a model driven approach.
17
[047] It is to be understood that the scope of the protection is extended to
such a program and in addition to a computer-readable means having a message
therein; such computer-readable storage means contain program-code means for
implementation of one or more steps of the method, when the program runs on a
5 server or mobile device or any suitable programmable device. The hardware device
can be any kind of device which can be programmed including e.g. any kind of
computer like a server or a personal computer, or the like, or any combination
thereof. The device may also include means which could be e.g. hardware means
like e.g. an application-specific integrated circuit (ASIC), a field-programmable
10 gate array (FPGA), or a combination of hardware and software means, e.g. an
ASIC and an FPGA, or at least one microprocessor and at least one memory with
software processing components located therein. Thus, the means can include both
hardware means and software means. The method embodiments described herein
could be implemented in hardware and software. The device may also include
15 software means. Alternatively, the embodiments may be implemented on different
hardware devices, e.g. using a plurality of CPUs.
[048] The embodiments herein can comprise hardware and software
elements. The embodiments that are implemented in software include but are not
limited to, firmware, resident software, microcode, etc. The functions performed
20 by various components described herein may be implemented in other components
or combinations of other components. For the purposes of this description, a
computer-usable or computer readable medium can be any apparatus that can
comprise, store, communicate, propagate, or transport the program for use by or in
connection with the instruction execution system, apparatus, or device.
25 [049] The illustrated steps are set out to explain the exemplary
embodiments shown, and it should be anticipated that ongoing technological
development will change the manner in which particular functions are performed.
These examples are presented herein for purposes of illustration, and not limitation.
Further, the boundaries of the functional building blocks have been arbitrarily
30 defined herein for the convenience of the description. Alternative boundaries can
be defined so long as the specified functions and relationships thereof are
18
appropriately performed. Alternatives (including equivalents, extensions,
variations, deviations, etc., of those described herein) will be apparent to persons
skilled in the relevant art(s) based on the teachings contained herein. Such
alternatives fall within the scope of the disclosed embodiments. Also, the words
5 “comprising,” “having,” “containing,” and “including,” and other similar forms are
intended to be equivalent in meaning and be open ended in that an item or items
following any one of these words is not meant to be an exhaustive listing of such
item or items, or meant to be limited to only the listed item or items. It must also
be noted that as used herein and in the appended claims, the singular forms “a,”
10 “an,” and “the” include plural references unless the context clearly dictates
otherwise.
[050] Furthermore, one or more computer-readable storage media may be
utilized in implementing embodiments consistent with the present disclosure. A
computer-readable storage medium refers to any type of physical memory on
15 which information or data readable by a processor may be stored. Thus, a
computer-readable storage medium may store instructions for execution by one or
more processors, including instructions for causing the processor(s) to perform
steps or stages consistent with the embodiments described herein. The term
“computer-readable medium” should be understood to include tangible items and
20 exclude carrier waves and transient signals, i.e., be non-transitory. Examples
include random access memory (RAM), read-only memory (ROM), volatile
memory, nonvolatile memory, hard drives, CD ROMs, DVDs, flash drives, disks,
and any other known physical storage media.
[051] It is intended that the disclosure and examples be considered as
25 exemplary only, with a true scope of disclosed embodiments being indicated by
the following claims.
19
We Claim:
1. A processor implemented method (300) for transformation of a legacy
application code, the method comprising:
5 providing, via one or more hardware processors, a legacy
application code as an input, wherein the legacy application code is written
in a source language (302);
parsing, via the one or more hardware processors, the legacy
application code using a parser (304);
10 splitting, via the one or more hardware processors, the parsed legacy
application code based on an application tier, wherein an output of the
splitting is in extensible markup language (XML) specifications (306);
creating, via the one or more hardware processors, an intermediate
model for a plurality of functionalities in the legacy code using the XML
15 specifications comprising relevant business logic (308);
generating, via the one or more hardware processors, a second
intermediate model from the first intermediate model using a model creator
to make the legacy code as technology independent, wherein the second
intermediate model comprises a plurality of technology independent
20 models corresponding to the plurality of functionalities present in the
legacy code (310);
selecting, via the one or more hardware processors, a target
technology stack by the user (312);
generating, via the one or more hardware processors, a scaffolding
25 code for the target technology stack selected by the user (314);
mapping, via the one or more hardware processors, syntax of the
source language of the legacy application code to the language of the target
technology stack using a code transformation unit to obtain a transformed
business logic (316);
30 generating, via the one or more hardware processors, a technology
specific code corresponding to the target application based on the second
20
intermediate model and the transformed business logic using a code
generator (318); and
packaging and deploying, via the one or more hardware processors,
the technology specific code into a format applicable for one of a cloud or
5 traditional deployment environment (320).
2. The method of claim 1 further comprising creating and integrating
reference libraries for data-format-conversion, to enhance code reusability
and readability.
10
3. The method of claim 1 wherein the first intermediate model comprises one
or more of a user interface (UI) layer, a UI-controller mapping layer, a
business layer, a controller layer, an object layer, or a data access ObjectObject mapping layer.
15
4. The method of claim 1, wherein generated technology specific code is
compliant to a predefined security criterion, a performance standard and a
set of legal requirements.
20 5. A system (100) for analyzing a plurality of data streams in real time, the
system comprises:
an input/ output interface (104) configured to provide a legacy
application code as an input, wherein the legacy application code is written
in a source language;
25 one or more hardware processors (108); and
a memory (110) in communication with the one or more hardware
processors, wherein the one or more first hardware processors are
configured to execute programmed instructions stored in the memory to:
parse the legacy application code using a parser (114);
21
split the parsed legacy application code based on an
application tier, wherein an output of the splitting is in extensible markup
language (XML) specifications;
create an intermediate model for a plurality of
5 functionalities in the legacy code using the XML specifications comprising
relevant business logic;
generate a second intermediate model from the first
intermediate model using a model creator (118) to make the legacy code as
technology independent, wherein the second intermediate model comprises
10 a plurality of technology independent models corresponding to
functionalities present in the code;
select a target technology stack by the user;
generate a scaffolding code for the target technology stack
selected by the user;
15 map syntax of the source language of the legacy application
code to the language of the target technology stack using a code
transformation unit (122) to obtain a transformed business logic;
generate a technology specific code corresponding to the
target application based on the second intermediate model and the
20 transformed business logic using a code generator (124); and
package and deploy the technology specific code into a
format applicable for one of a cloud or traditional deployment environment.
6. The system of claim 5 further configured to create and integrate reference
25 libraries for data-format-conversion, to enhance code reusability and
readability.
7. The system of claim 5, wherein the first intermediate model comprises one
or more of a user interface (UI) layer, a UI-controller mapping layer, a
30 business layer, a controller layer, an object layer, or a data access ObjectObject mapping layer.
22
8. The system of claim 5, wherein generated technology specific code is
compliant to a predefined security criterion, a performance standard and a
set of legal requirements.