System and method for accelerating modernization of user interfaces in a computing environment

A system and method for accelerating modernization of user interfaces in a computing environment is disclosed. The method includes receiving request for transforming a current graphical user interface (GUI) corresponding to current programming language and associated software framework to a target GUI corresponding to target programming language and associated software framework. The method includes capturing run time application attributes during an active interactive session of the user interface with user devices. Further, the method includes determining static application attributes from the source code of the current application. The method includes generating application attribute model representing relationships between static application attributes and run time application attributes. The method further includes automatically generating a target application attribute model corresponding to the target programming language and associated software framework based on the application attribute model. Also, the method includes generating a set of executable program code and non-executable assets corresponding to the target programming language and associated software framework based on the target application attribute model. Furthermore, the method includes outputting the generated set of executable program code and non-executable assets on a user interface of the user device.

FIELD OF INVENTION

Embodiments of a present disclosure relate to computing systems and more particularly to a system and a method for accelerating modernization of user interfaces in a computing environment.

BACKGROUND

Modernization from legacy technology to new technology is often requiring significant manual intervention. Manual work is error-prone due to the size of large legacy software that cannot be fully managed by a human mind (complexity, volume of algorithms and information). Hundreds and even thousands of man-days are required to modernize average legacy software.

Transformations applied for modernizing software are similar to decompiling and recompiling programming languages. Therefore, it is highly complex or even impossible for users of modernization systems (methods, tools, and the like), to customize transformations. As a consequence, it is very difficult to modernize all the legacy code because of ambiguities in legacy code semantics and numerous exceptions to design patterns.

Hence, there is a need for an improved system and a method for auto generating code in a desired language in order to address the aforementioned issues.

SUMMARY

This summary is provided to introduce a selection of concepts, in a simple manner, which is further described in the detailed description of the disclosure. This summary is neither intended to identify key or essential inventive concepts of the subject matter nor to determine the scope of the disclosure.

In accordance with an embodiment of the present disclosure, a system for accelerating modernization of user interfaces in a computing environment is disclosed. The system includes one or more hardware processors and a memory coupled to the one or more hardware processors. The memory includes a plurality of subsystems in the form of programmable instructions executable by the one or more hardware processors. The plurality of subsystems includes a request handler subsystem configured for receiving a request for upgrading a current graphical user interface corresponding to a current programming language and associated software framework to a target graphical user interface corresponding to a target programming language and associated software framework the plurality of subsystem further includes a run time application attribute capturing subsystem configured for capturing one or more run time application attributes associated with the current graphical user interface of a web application during an ongoing communication session with one or more user devices. Furthermore, the plurality of subsystem includes a static application attribute determination subsystem configured for determining one or more static application attributes associated with the graphical user interface of the web application from one or more data sources. The one or more static application attributes corresponds to the current programming language and associated software framework. Further, the plurality of subsystem includes an application attribute model generator subsystem configured for generating an application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes. The application attribute model corresponds to the current programming language and associated software framework. Also, the plurality of subsystem includes a target application attribute model generator subsystem configured for automatically generating a target application attribute model corresponding to the target programming language and associated software framework based on the generated application attribute model. Also, the plurality of subsystem include a program code generator subsystem configured for generating a set of executable program code corresponding to the target programming language and associated software framework based on the generated target application attribute model. Additionally, the plurality of subsystem includes an output subsystem configured for outputting the generated set of executable program code along with non-executable assets on a user interface of the user device.

In accordance with another embodiment of the present disclosure, a method for accelerating modernization of user interfaces in a computing environment is disclosed. The method includes receiving a request for upgrading a current graphical user interface corresponding to a current programming language and associated software framework frameworks to a target graphical user interface corresponding to a target programming language and associated software framework frameworks. The method further includes capturing one or more run time application attributes associated with the current graphical user interface of a web application during an ongoing communication session with one or more user devices. Further, the method includes determining one or more static application attributes associated with the graphical user interface of the web application from one or more data sources. The one or more static application attributes corresponds to the current programming language and associated software framework. Additionally, the method includes generating an application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes. The application attribute model corresponds to the current programming language and associated software framework. The method further includes automatically generating a target application attribute model corresponding to the target programming language and associated software framework based on the generated application attribute model. Also, the method includes generating a set of executable program code corresponding to the target programming language and associated software framework based on the generated target application attribute model. Furthermore, the method includes outputting the generated set of executable program code along with non-executable assets on a user interface of the user device.

DETAILED DESCRIPTION OF THE DISCLOSURE

The terms “comprise”, “comprising”, or any other variations thereof, are intended to cover a non-exclusive inclusion, such that one or more devices or sub-systems or elements or structures or components preceded by “comprises . . . a” does not, without more constraints, preclude the existence of other devices, sub-systems, additional sub-modules. Appearances of the phrase “in an embodiment”, “in another embodiment” and similar language throughout this specification may, but not necessarily do, all refer to the same embodiment.

Throughout this document, the terms browser and browser application may be used interchangeably to mean the same thing. In some aspects, the terms web application and web app may be used interchangeably to refer to an application, including metadata, that is installed in a browser application. In some aspects, the terms web application and web app may be used interchangeably to refer to a website and/or application to which access is provided over a network (e.g., the Internet) under a specific profile (e.g., a website that provides email service to a user under a specific profile). The terms extension application, web extension, web extension application, extension app and extension may be used interchangeably to refer to a bundle of files that are installed in the browser application to add functionality to the browser application. In some aspects, the term application, when used by itself without modifiers, may be used to refer to, but is not limited to, a web application and/or an extension application that is installed or is to be installed in the browser application.

Embodiments of the present disclosure disclose a system and method for management of the computing assets. The present disclosure simplifies the process of user interface (UI) modernization by providing a toolchain to capture the dynamic attributes (at runtime) of a web application. These dynamic attributes are then coupled with the static attributes (in the source code) which are then used to generate code, test cases, and documentation to aid in the transformation effort and to reduce the effort of migration and improve time to market.

FIG.1is a block diagram illustrating an exemplary computing environment100for accelerating modernization of user interfaces in accordance with an embodiment of the present disclosure. According toFIG.1, the computing environment100comprises a computing system102which is capable of delivering web applications for managing an integrated development environment110. Throughout the specification the term ‘computing system’ may also be referred as ‘system’ and the ‘computing system’. The computing system102is connected to a web application108in the user device106via a network104(e.g., Internet). In one specific embodiment, the one or more communication networks104may include, but not limited to, an internet connection, a wireless fidelity (WI-FI) and the like. Although,FIG.1illustrates the computing system102connected to one user device106, one skilled in the art can envision that the computing system102can be connected to several user devices located at different locations via the network104. In an embodiment, the web application108may be hosted on a remote web server from where it is loaded on a “web browser” on the user device106. In such case, the computing system102may be a remote web server.

In an embodiment, the computing system102may be a remote server, an edge device, a user device, a cloud server and the like.

The user devices106can be a laptop computer, desktop computer, tablet computer, smartphone and the like. The user device106can access cloud applications via a web browser. The user device106includes a web application108and an Integrated development environment110. The web application108may be a web page that has client-side scripting language. In an embodiment, the web application108may be loaded onto the web browser of the user device108from the remote web server.

As an example, a user of a user device106may access a particular web application by launching a web browser, typing into the web browser's address bar a Uniform Resource Locator (URL) address for a web page whose rendering causes execution of a web application, and selecting an “enter” key on the user's keyboard. The web browser may send a Hypertext Transfer Protocol (HTTP) request over the internet for resources that correspond to the URL.

In response to the HTTP request, the web browser may receive from the computing system102, a set of resources that the computing system102identified as relevant for the URL (e.g., HTML, for a web page, a CSS document, and a JavaScript file). The web browser may execute the resources, for example, by rendering a parent HTML file and executing other resources referenced therein. The execution of the resources may cause the web browser to effectively “display” the web application108on a display device of the user device106.

The web application108may be a normal website that includes extra metadata that is installed as part of the browser application. Installable web apps may use standard web technologies for server-side and client-side code. Examples of web applications include office applications, games, photo editors, and video players that are run inside the browser.

In various examples, the web browser may include or be configured to interact with one or more browser extensions. In this context, a “browser extension” may include one or more web pages packaged or grouped together as a definable whole and configured to extend the functionality to the web browser. As described herein, “browser extensions” are small software programs that can modify and enhance the functionality of a web browser. They may be written using web technologies such as HTML, JavaScript, and CSS. Extensions may have little or no user interface. In some implementations, extensions may provide a small user interface icon or other user interface that may modify a browser's “chrome”, which is defined herein to include an area outside of a webpage displayed in the browser (such as the borders of a web browser window, which include the window frames, menus, toolbars and scroll bars). Selecting the icon or the other user interface may activate the functionality of the extension within the browser. Extensions may include extra metadata that is associated with the application, which affects the web application's interaction with the browser application.

In a preferred embodiment, such extensions may be used for dynamically capturing the run time application attributes of the web application108.

The web application108includes an interactive graphical user interface. A graphical user interface is a collection of one or more graphical interface elements and may be static (e.g., the display appears to remain the same over a period of time), or may be dynamic (e.g., the graphical user interface includes graphical interface elements that animate without user input).

A graphical interface element may be text, lines, shapes, images, or combinations thereof. For example, a graphical interface element may be an icon that is displayed on the desktop and the icon's associated text. Each of the graphical interface elements are referred to herein as the application objects.

The integrated development environment (IDE)110comprises tools for software development in a variety of different programming languages, such as Java, C++, and JavaScript. Examples of tools include source code editors, compilers, interpreters, build automation tools, and debuggers. Additionally, in accordance with embodiments of the present invention, the integrated development environment110may facilitate virtualization of an application across the computing system102. In particular, the integrated development environment110can accept and accommodate plug-in tools that facilitate the deployment of applications in the computing environment100. The IDE110may present the generated set of code to the user, who may then modify the received code, such as by way of the IDE110.

The computing system102includes a processor112, a database114, and a memory118. The processor112, and the memory114, may be communicatively coupled by a system bus such as a system bus116or a similar mechanism. The computing system102further includes a cloud interface, a server including hardware assets and an operating system (OS), a network interface, and application program interfaces (APIs). The cloud interface enables communication between the server and the user device106. As used herein, “computing environment” refers to a processing environment comprising configurable computing physical and logical assets, for example, networks, servers, storage, applications, services, etc., and data distributed over the cloud platform. The computing environment100provides on-demand network access to a shared pool of the configurable computing physical and logical assets. The server may include one or more servers on which the OS is installed. The servers may comprise one or more processors, one or more storage devices, such as, memory units, for storing data and machine-readable instructions for example, applications and application programming interfaces (APIs), and other peripherals required for providing computing functionality.

The processor(s)112, as used herein, means any type of computational circuit, such as, but not limited to, a microprocessor unit, microcontroller, complex instruction set computing microprocessor unit, reduced instruction set computing microprocessor unit, very long instruction word microprocessor unit, explicitly parallel instruction computing microprocessor unit, graphics processing unit, digital signal processing unit, or any other type of processing circuit. The processor(s)112may also include embedded controllers, such as generic or programmable logic devices or arrays, application specific integrated circuits, single-chip computers, and the like.

The memory118may be non-transitory volatile memory and non-volatile memory. The memory118may be coupled for communication with the processor(s)112, such as being a computer-readable storage medium. The processor(s)112may execute machine-readable instructions and/or source code stored in the memory118. A variety of machine-readable instructions may be stored in and accessed from the memory118. The memory118may include any suitable elements for storing data and machine-readable instructions, such as read only memory, random access memory, erasable programmable read only memory, electrically erasable programmable read only memory, a hard drive, a removable media drive for handling compact disks, digital video disks, diskettes, magnetic tape cartridges, memory cards, and the like. In the present embodiment, the memory118includes a plurality of subsystems stored in the form of machine-readable instructions on any of the above-mentioned storage media and may be in communication with and executed by the processor(s)112.

The memory118includes a plurality of subsystems in the form of programmable instructions executable by one or more hardware processors112. The plurality of subsystems includes a request handler subsystem120configured for receiving a request for upgrading a current graphical user interface corresponding to a current programming language and associated software framework to a target graphical user interface corresponding to a target programming language and associated software framework. The current graphical user interface is associated with the current web application108. The current programming language and the associated software framework may be for example, but not limited to, a JavaScript programming language and Java user interface (UI) software framework. The software framework may be a user interface framework corresponding to the programming language. The target graphical user interface may be associated with a target web application (not shown). The target programming language and associated software framework may be for example, but not limited to, a JavaScript language and the AngularJS framework. The target graphical user interface may include improved view than the current graphical user interface.

The plurality of subsystem further includes a run time application attribute capturing subsystem122configured for capturing one or more run time application attributes associated with the current graphical user interface of the web application108during an ongoing communication session with one or more user devices106. The one or more run time application attributes comprises graphical user interface elements, hierarchy of application objects, navigation with respect to user interaction with the graphical user interface elements, web page complexity, network invocations and the like. The ongoing communication session is an active session between the computing system102and the user device106. The run time application attribute capturing subsystem122may use one or more browser extensions (as described above) for capturing the one or more run time application attributes. In capturing the one or more run time application attributes associated with the current graphical user interface, the run time application attribute capturing subsystem122is configured for detecting one or more actions performed at one or more application objects present at the current user interface. The one or more actions comprises user actions such as clicking an application object by the user, navigation paths during the use of the application, form elements, code that is executed during interactions, form element validation logic and the like. Further, the run time application attribute capturing subsystem122is configured for analyzing behavior of each of the one or more application objects during the one or more actions performed. For example, the behavior of each of the one or more application objects may be changing of color of the application object, navigating to a new web page, establishing or terminating the sessions, and the like. In an embodiment, if a user clicks (action) on an icon in the web application108, the run time application attribute capturing subsystem122observes the behavior of the application objects in the web application108and records the same. Further, the run time application attribute capturing subsystem122is configured for determining the one or more run time application attributes associated with each of the one or more application objects based on the analyzed behavior. The one or more run time application attributes comprises behavioral attributes and the application object attributes. The behavioral attributes comprises in-page clicks, mouse movement, scroll depth, user navigation patterns, live visitors, recordings, site speed and the like. The application object attributes comprises size, color, placement and other design attributes.

Further, the run time application attribute capturing subsystem122is further configured for generating a run time attribute model for the determined one or more run time application attributes. The run time attribute model represents a hierarchical relationship between each of the determined one or more run time application attributes. For example, the run time attribute model may be a tree-based model representing the hierarchical relationship.

The plurality of subsystem further includes a static application attribute determination subsystem124configured for determining one or more static application attributes associated with the graphical user interface of the web application from one or more data sources. The one or more static application attributes corresponds to the current programming language and associated software framework. The one or more static application attributes comprises source code, source code, references to code/or business logic, business rules, code validations, alternate flows, and other static characteristics. The one or more static application attributes may conform to the current programming language, such as for example, source code in JavaScript. The one or more data sources may be a cloud database114, any external databases or locally hosted databases on the user device106. In determining the one or more static application attributes associated with the graphical user interface of the web application108from the one or more data sources, the static application attribute determination subsystem124is configured for extracting a source code associated with the current graphical user interface from the one or more data sources. The source code may be stored locally on the user device106or on any external data sources accessible by the computing system102. The static application attribute determination subsystem124is configured for determining one or more static references associated with the current graphical user interface by applying one or more static analysis rules. The one or more static references may be references to business logic in the source code that is associated with runtime actions, call hierarchy, graph and the like. Further, the one or more static analysis rules comprises static code level metrics of code quality, complexity and re-usability and the like. Furthermore, the static application attribute determination subsystem124is configured for determining the one or more static application attributes associated with the current graphical user interface based on the extracted source code.

The plurality of subsystem further includes an application attribute model generator subsystem126configured for generating an application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes. The application attribute model corresponds to the current programming language and associated software framework. The application attribute model may be a relationship matrix, a hierarchical tree structured model or any machine learning based or artificial intelligence-based model. The application attribute model depicts how the various application objects are correlated. The application attribute model also indicates the behavioural attributes, and the functional attribute depicting how each application object behaves and the function performed by each application object. In generating the application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes, the application attribute model generator subsystem126is configured for determining current programming language properties associated with the one or more run time application attributes and the one or more static application attributes. The current programming language properties comprises syntax, semantics, pragmatics, looping and branching, mark-up and control language, access to internal system variables, binary and text file I/O, ODBC/SQL support, access to files on the Internet, list processing and the like. Further, the application attribute model generator subsystem126is configured for modifying the current programming language properties to a common programming language format by mapping each of the one or more run time application attributes and the one or more static attributes with a corresponding pre-stored application language rules. For example, the common programming language format may be. The pre stored application language rules may be syntax-based rules, looping and branching rules, library rules and the like. In an embodiment, the current programming languages, for example, JavaScript may be converted into a common programming language format such as C language. Further, the application attribute model generator subsystem126is configured for correlating the one or more static attributes with the one or more run time application attributes based on the conversion. For example, each of the one or more static attributes is inter-related to each of the one or more run time application attributes. In an embodiment, context-based relationship is inferred from the one or more static attributes and the one or more run time application attributes. This may be achieved using for example any machine learning or artificial intelligence-based techniques. Further, the application attribute model generator subsystem126is configured for generating the application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes. The application attribute model is a declarative “technology agnostic” model in a language neutral representation such as JSON or XML consisting of all run time and static attributes.

The plurality of subsystem further includes a target application attribute model generator subsystem128configured for automatically generating a target application attribute model corresponding to the target programming language based on the generated application attribute model. The target application attribute model may be a relationship matrix, a hierarchical tree structured model or any machine learning based or artificial intelligence-based model. The target application attribute model depicts how the various target application objects are correlated. The target application attribute model also indicates the behavioural attributes, and the functional attribute depicting how each target application object behaves and the function performed by each target application object. The target application object are the GUI elements desired to be designed in the target graphical user interface. In an exemplary embodiment, the application attribute model is modified or transformed into the target application attribute model by transforming the run time and static application attributes from one programming language to other. In automatically generating the target application attribute model corresponding to the target programming language based on the generated application attribute model, the target application attribute model generator subsystem128is configured for determining type of target programming language to which the current programming language and associated software framework of the current graphical user interface is to be upgraded based on the received request. The request is parsed to determine the type of the target programming language and associated software framework. The request may include user selection indicating the target programming language or any other identifier. Further, the target application attribute model generator subsystem128is configured for determining programming language properties associated with the determined type of the target programming language. This determination may be made based on stored language models. Furthermore, the target application attribute model generator subsystem128is configured for generating a target run time application attributes and target static attributes corresponding to the target programming language based on the determined programming language properties. Furthermore, the target application attribute model generator subsystem128is configured for generating the target application attribute model corresponding to the target programming language by modifying the current one or more run time application attributes and the current one or more static application attributes in the application attribute model to the target run time application attributes and target static attributes.

The plurality of subsystem further includes a program code generator subsystem130configured for generating a set of executable program code corresponding to the target programming language based on the generated target application attribute model. The set of executable program code may include machine readable instructions for a programmable processor112configured for executing the web application108. The set of executable program code comprises source code, object code, scripts for test cases, backend service or API stubs, and non-code assets such as documentation, effort estimation models and the like. The set of executable program code may conform to the target programming language and associated software framework, such as for example, JavaScript, AngularJS and React. The set of executable program code are editable, compilable and deployable on any given software platform that the target programming language code and associated software framework is supported for. In generating a set of executable program code corresponding to the target programming language and associated software framework based on the generated target application attribute model, the program code generator subsystem130is configured for determining one or more application objects to be present in the target graphical user interface based on the generated target application attribute model. Furthermore, the program code generator subsystem130is configured for dynamically linking each of the determined one or more application objects with one or more actions based on the generated target application attribute model. For example, the home icon may be associated with an action of navigating the user back to the main page of the website. Furthermore, the program code generator subsystem130is configured for generating the set of executable program code and the non-executable assets for each of the one or more application objects to be present in the target programming language based on the dynamic link. The set of executable program code comprises executable source code, executable test cases and executable application libraries.

In an embodiment, the program code generator subsystem130leverages “adapters” for specific backend technologies (such as for example, Angular, React, Selenium) and hence provide extensibility to additional technologies in the future via custom generators.

Furthermore, the program code generator subsystem130is configured for generating one or more reference document files corresponding to the generated set of executable program code based on content, type and function of the program code.

In an embodiment, the program code generator subsystem130generates, for example, a scaffolded project for a given target programming language and associated software framework. Further, the program code generator subsystem130generates documentation using information captured in the model.

The plurality of subsystem further includes an output subsystem132configured for outputting the generated set of executable program code along with non-executable assets on a user interface of the user device106. The set of executable program code may be displayed on the user interface of the user device106. The non-executable assets may be documents and effort sizing assets.

Further, the plurality of subsystem further includes an identity management subsystem (not shown) to provide the capability to manage and authorize users for the API.

Further, the plurality of subsystem further includes a deployment subsystem (not shown) configured for deploying the generated set of executable program code at the one or more user devices connected via the network.

The plurality of subsystem further includes an application report generation subsystem (not shown) configured for identifying one or more application issues associated with the current graphical interface based on the generated application attribute model. The one or more application issues comprises programming issues, navigation issues, interaction issues, user interface elements issues and network invocation issues. The programming issues may be syntax issues, compatibility issues and the like. The navigation issues may be like circular and complex navigation. The interaction issues may be like ‘element not working’, and the like. The user interface elements issues may be like accessibility related, regulatory best practices and the like. The network invocation issues may be like potential insecure usage. The application attribute model and the target application attribute model may be parsed, analysed and validated to check if there are any issues existing in any part of the web application108. This process helps in identifying if there are any issues associated with the current graphical interface. If there are any issues identified, such issues may be appended on the respective application object present in either the application attribute model or the target application attribute model.

Further, the application report generation subsystem is configured for generating one or more web application reports associated with the current graphical interface. The one or more web application reports comprises the identified one or more application issues. The one or more web application reports are annotatable and downloadable onto the user device106.

The database114stores the information relating to the web application108and the IDE110. The database114is configured as a store of structured or unstructured data implemented in the computing environment100, where web application108are delivered as a service over a network. The database114, according to another embodiment of the present disclosure, is a location on a file system directly accessible by the plurality of subsystems. The database114is configured to store web application information, programming language information, graphical user interface information, user information and the like. In an embodiment, a document-oriented database such as Mongo may be used.

Those of ordinary skilled in the art will appreciate that the hardware depicted inFIG.1may vary for particular implementations. For example, other peripheral devices such as an optical disk drive and the like, Local Area Network (LAN), Wide Area Network (WAN), Wireless (e.g., Wi-Fi) adapter, graphics adapter, disk controller, input/output (I/O) adapter also may be used in addition or in place of the hardware depicted. The depicted example is provided for the purpose of explanation only and is not meant to imply architectural limitations with respect to the present disclosure.

FIG.2is snapshot view of an exemplary web application running on a web browser of a user device, such as those shown inFIG.1in accordance with an embodiment of the present disclosure. InFIG.2, a web application202, such as the web application108, running on a web browser is shown. The web application202comprises one or more application objects, such as ‘products’, ‘services’, ‘about’, ‘contact’ and the like. At the lower side ofFIG.2, a window of integrated development environment204, such as the IDE110, is shown. When the run time application attribute capturing system122captures the run time application attributes during an active session, the IDE110depicts such captured application attributes in the form of a model. This model may be the run time attribute model as described above. In an embodiment, the run time application attribute capturing system122captures the dynamic or runtime attributes, such as navigational characteristics of the web application202while being used in a browser such as a chrome browser. Further, the run time application attribute capturing system122allows a user to annotate and tag requirements of the web application202dynamically and with reduced effort in capturing and maintaining key details. Key user interface elements, such as the application objects, may be selected, annotated and marked for re-use by the analyst. The captured dynamic attributes are represented in a model that is further used by other subsystems to finally generate the code.

FIG.3is a structural view300of the plurality of subsystems, such as those shown inFIG.1, in accordance with an embodiment of the present disclosure. This view300depicts separation of responsibilities by layer comprising subsystems. A layer above only communicates with the layer below. The run time application attribute model of the web application108is used to represent state used by each layer for performing its responsibility. Each layer communicates with the layer below using an interface, to insulate change and support extensibility and modifiability of its implementation. Each state is an internal application state of the solution as required to implement the functionality.

FIG.4is a block diagram illustrating a detailed view of a run time application attribute capturing subsystem122such as those shown inFIG.1, in accordance with an embodiment of the present disclosure. The run time application attribute capturing subsystem122comprises a Single Page Application (SPA) and security modules for authentication and authorization. The SPA is the single page application that provide the micro-UI in the browser to support the functionality of runtime attribute collection on the browser. The security modules are used to authorize and authenticate this component with the backend. The runtime application attribute capturing subsystem122is injected into data object model (DOM) of an active tab in the web browser. The runtime application attribute capturing subsystem122captures runtime attributes such as user interface element selection and hierarchy, navigation map, call-backs to user actions, application programming interface (API) calls to backend, and the like. These attributes are sent to a background worker using browser messaging API for further introspection of the application object or call. The runtime application attribute capturing subsystem122also comprises a local storage for storing the run time application attribute model, run time application attributes and other data. The run time application attribute capturing subsystem122is configured for transparently capturing the runtime attributes of the web application108, allows selection, annotation, grouping of elements to capture relationships and maintain the representation in a model.

FIG.5is a block diagram illustrating a detailed view of a static application attribute determination subsystem124such as those shown inFIG.1, in accordance with an embodiment of the present disclosure. The static application attribute determination subsystem124comprises server component that hosts the SPA and exposes a REST API for consumption by the run time application attribute capturing subsystem122. This is designed for standalone use on a single machine as well as being extensible for a networked multi-user setup supporting multiple client devices. The design leverages the following abstractions for technology agnosticity, portability, and extensibility. For example, the RESTful API to the run time application attribute capturing subsystem122insulates any technology dependency on its implementation. In an embodiment, Node.js and Express may be used to host this runtime. This is the interface for the SPA. The SPA is hosted by Express, however also supports standalone hosting of static content (via nginx, Apache, S3 and the like). The static application attribute determination subsystem124is configured for identifying static application attributes such as re-usable components, code complexity and sizing metrics. The static application attribute determination subsystem124establishes a relationship between component action and the source code for developer productivity migration.

FIG.6is a block diagram illustrating an exemplary modernization environment600deployed in a user device for accelerating modernization of user interfaces from a single user configuration perspective, in accordance with an embodiment of the present disclosure. In an embodiment, the modernization environment600may be designed to be hosted on a single computer for single-user operation. The server component may be containerized for ease of use, portability, runtime simplification and standardization. The static application attribute such as the source code is referenced either via references to the local filesystem or via git version control. For longer running components in the static application attribute determination subsystem124, worker processes are used for better user experience and responsiveness of the UI. In an exemplary embodiment of a single user configuration, the document-oriented database (Mongo) is included in a Docker container to ease setup, and portability of the runtime components.

FIG.7is a block diagram illustrating an exemplary modernization environment700deployed in multiple user devices for accelerating modernization of user interfaces from a multiuser configuration perspective, in accordance with an embodiment of the present disclosure. In an embodiment, the modernization environment700may be designed to address issues of scalability and extensibility of this architecture to networked multi-user configurations.

In an exemplary embodiment, the same components used in standalone mode may be extended to a networked configuration by deploying the Docker container in either virtual machines or orchestration environments such as OpenShift or Kubernetes. In this configuration, the document-oriented database (Mongo) may either be local to the container or external depending on scalability needs. This supports the horizontal scaling of the Node.js or Express components. In a container orchestrated environment, a persistent storage volume shall be shared by all the containers for storage of source and analysis assets.

FIG.8is a process flow diagram illustrating an exemplary method800for managing computing assets in accordance with an embodiment of the present disclosure. At step802, a request for upgrading a current graphical user interface corresponding to a current programming language and associated software framework to a target graphical user interface corresponding to a target programming language and associated software framework is received. At step804, one or more run time application attributes associated with the current graphical user interface of a web application108is captured during an ongoing communication session with one or more user devices106. At step806, the one or more static application attributes associated with the graphical user interface of the web application108is determined from one or more data sources. The one or more static application attributes corresponds to the current programming language and associated software framework. At step808, an application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes is generated. The application attribute model corresponds to the current programming language and associated software framework. At step810, a target application attribute model corresponding to the target programming language and associated software framework is automatically generated based on the generated application attribute model. At step812, a set of executable program code corresponding to the target programming language and associated software framework is generated based on the generated target application attribute model. At step814, the generated set of executable program code and non-executable assets are output on a user interface of the user device106.

Further, the method800includes validating the generated set of executable program code based on one or more predefined validation rules. Also, the method800includes deploying the generated set of executable program code at the one or more user devices106connected via the network104.

Further, the method800includes identifying one or more application issues associated with the current graphical interface based on the generated application attribute model. The one or more application issues comprises programming issues, navigation issues, interaction issues, user interface elements issues and network invocation issues. Further, the method800includes generating one or more web application reports associated with the current graphical interface. The one or more web application reports comprises the identified one or more application issues.

In capturing the one or more run time application attributes associated with the current graphical user interface of the web application108during the ongoing communication session with one or more user device106, the method800includes detecting one or more actions performed at one or more application objects present at the current user interface. The method800further includes analysing behaviour of each of the one or more application objects during the one or more actions performed. Also, the method800further includes determining the one or more run time application attributes associated with each of the one or more application objects based on the analysed behaviour. The one or more run time application attributes comprises behavioural attributes and the application object attributes. The method800also includes generating a run time attribute model for the determined one or more run time application attributes. The run time attribute model represents a hierarchical relationship between each of the determined one or more run time application attributes.

In determining the one or more static application attributes associated with the graphical user interface of the web application108from the one or more data sources, the method800includes extracting a source code associated with the current graphical user interface from the one or more data sources. The method800further includes determining one or more static references associated with the current graphical user interface by applying one or more static analysis rules. Also, the method800further includes determining the one or more static application attributes associated with the current graphical user interface based on the extracted source code.

In generating the application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes, the method800includes determining current programming language and associated software framework properties related to one or more run time application attributes and the one or more static application attributes. Further, the method800includes modifying the current programming language and associated software framework properties to a common programming language format by mapping each of the one or more run time application attributes and the one or more static attributes with a corresponding pre-stored application language rules. Furthermore, the method800includes correlating the one or more static attributes with the one or more run time application attributes based on the conversion. Further, the method800includes generating the application attribute model representing relationships between the one or more static application attributes and the one or more run time application attributes.

In automatically generating the target application attribute model corresponding to the target programming language and associated software framework based on the generated application attribute model, the method800includes determining type of target programming language and associated software framework to which the current programming language and associated software framework associated with the current graphical user interface is to be upgraded based on the received request. The method800includes determining programming language properties associated with the determined type of the target programming language and associated software framework. The method800includes generating a target run time application attributes and target static attributes corresponding to the target programming language and associated software framework based on the determined programming language properties. Further, the method800includes generating the target application attribute model corresponding to the target programming language by modifying the current one or more run time application attributes and the current one or more static application attributes in the application attribute model to the target run time application attributes and target static attributes.

In generating a set of executable program code corresponding to the target programming language and associated software framework based on the generated target application attribute model, the method800includes determining one or more application objects to be present in the target graphical user interface based on the generated target application attribute model. The method800includes dynamically linking each of the determined one or more application objects with one or more actions based on the generated target application attribute model. The method800further incudes generating the set of executable program code and non-executable assets for each of the one or more application objects to be present in the target programming language and associated software framework based on the dynamic link. The set of executable program code comprises executable source code, executable test cases and executable application libraries. The method800includes generating one or more reference document files corresponding to the generated set of executable program code based on content, type and function of the program code.

Various embodiments of the present system provide a technical solution to the problem of migrating from a legacy user interface technology to a newer one faster through automation and intelligent attribute capture. The present system provides browser-based toolchain to capture an application's functionality, navigation, validations, and re-usable components, automatically to generate code, documentation, and test case assets.

It will be understood by those skilled in the art that the foregoing general description and the following detailed description are exemplary and explanatory of the disclosure and are not intended to be restrictive thereof.