Blu Age Reverse Modeling
Hide the picture/Show the picture
Blu Age Reverse Modeling extracts the functional specifications of your “legacy" applications in order to set them up in UML2 language. What for? To accelerate and automate the modernization by the automatic generation of business models or description of management rules. These business models will be then compiled by Blu Age Forward Engineering to automatically produce your entire new application in Java JEE or .Net.
From the "legacy" code, Blu Age Reverse Modeling, reconstitutes the functional logic as UML2 diagrams. This retro-modeling allows you to regain knowledge previously "buried" in legacy applications often opaque. It is also the guarantee to capitalize on the processes and rules driven by the application by eliminating the drawbacks of an aging code.
According to Gartner 80% of the business behavior of an application is implemented by only 20% of the source code of the application. According to the principles of MDA (Model Driven Architecture), Blu Age isolates the functional logic of the code, which allows to modernize at a lower cost and to reinforce the agility of the future application. Blu Age Reverse Modeling is based on a knowledge that describes grammars and design patterns (code organization and treatment) specific to the languages and development norms used.
Blu Age Reverse Modeling supports the first of three stages covered by Blu Age Application Modernization and integrates itself with other products of the solution.
With Blu Age Reverse Modeling, business code of the code is isolated and extracted in UML2. Through this process and together with Blu Age Forward Engineering, your new application will be shaped to bring you the following benefits:
- A limited cost of ownership (enhancement and maintenance)
- Highly reduced modernization budgets and deadlines,
- Agile processes as modeled in UML2
- A recovered technological freedom (Blu Age generates the modernized application on the architecture of your choice: JEE or. Net)
- A code quality measurable and respecting norms and standards consistently,
- The opportunity to regain your applications and to have them maintained by your teams including the new generation not trained to old languages.
The unique functionalities of Blu Age are the following:
- Automate your modernization projects to reduce their budgets
- Blu Age Reverse Modeling automates reverse engineering phase towards models compilable by Blu Age Forward Engineering. Far from being contemplative, these models are the living matter with which your development teams work. Once Blu Age Reverse Modeling sets up according to the architecture of your old application, the modernization is done automatically. Changeable, extracted functional models allow the enhancement of the application with competitive advantages of time, budget and quality..
- Reconstruct the knowledge of your processes and business rules
- The applications to be modernized are those whose value lies in the implemented processes. Blu Age Reverse Modeling recreates the business knowledge supported by your applications in UML2 format. A business knowledge then made usable and scalable with Blu Age Forward Engineering.
- Limit the causes of technological and human failures
The business model extracted by Blu Age Reverse Modeling in UML2 format can be used:
Business processes and rules are reconstructed independently of any development technology.
- by your staff as a detailed functional specification,
- to fully automate the generation of your application towards the architecture of your choice: Java or. Net.
- No dependency
- Applications produced with Blu Age do not depend of Blu Age in any way:
- Upstream: UML2 models meet the standards of the OMG (Object Management Group)
- Downstream: the generated code does not depend on a runtime or any framework
- A knowledge base for Legacy languages and their technical architectures
- Blu Age Reverse Modeling relies on a knowledge base that describes:
- the grammar of each supported language,
- the specific elements of architecture for a given language,
- design patterns (code organization and process) specific to the languages and used development standards,
- all changes towards UML2 associated with the elements of language knowledge.
- A knowledge base to set up your architecture and programming practices
- Each application has been implemented according to standards and specific programming practices. These items are identified and integrated in a computer aided manner to enhance the knowledge base. This knowledge becomes immediately available to the project team in charge of the modernization in order them to get additional controllers.
- A publisher specialized in modernizing your applications without any knowledge of the old programming languages
- Blu Age Reverse Modeling, automatically and integrally, extracts all the source code towards technical models that can be used without knowledge of the “old” languages as PSM -Platform Specific Models. This allows any IT engineers to take part in the modernization of an application without mastering its original language. These technical models are exploited by a set of analysis views and annotation publishers that enable to simply set the modernization of your application.
- A set of analysis views for analysis for a better understanding of the existing and to define the new architecture
- Blu Age Reverse Modeling has a dedicated perspective in Eclipse that integrates a set of views for you to analyze your application and decide on options of modernization:
- Call tree,
- Collaboration diagram between programs,
- Data Flow,
- Object instances,
- Analysis of side effect for global variables,
- Structure functions,
- Wizards to simplify the setup of changes
- Blu Age integrates fully automated wizards to modernize your applications. These wizards are based on ontologies of the Blu Age Reverse Modeling knowledge base to automatically transform and restructure for a modernization towards a SOA architecture.
- An integrated environment for modeling and development by models
- Modernization is the beginning of a new life for your application. Environment for modeling and development integrated in Eclipse, Blu Age provides a management of your applications lifeclycle according to the MDA principles. The future enhancements of the application are made by updating models and their compilation. Well beyond the simple change of technical platform, Blu Age enables to manage non-intrusively the application lifecycle by automating development tasks related to:
- functional enhancements,
- technical maintenance,
- continuous integration,
- collaborative management of project management, development and maintenance,
- on-demand generation in the object architecture of your choice.
- Tools for automatic detection and validation of patterns
- Before extracting the UML2 models, you can have Blu Age to analyze the code in order to display the changes to be applied, program by program, code by code. It is thus possible to validate and / or modify the intended actions.
- An extensible knowledge base to increase the rate of automation
- Blu Age Reverse Modeling is based on a knowledge base that organizes the concepts of language, architecture and the associated transformations. This knowledge base is expandable in order to consider and automate:
- programming practices within a specific legacy application,
- architectural elements specific to your application (transaction processing and errors management for example),
- specific technologies: dialect variant for example (version of Cobol, version of Natstar ...).
- The possibility to annotate the code for specific processes
- Blu Age Reverse Modeling allows the user to annotate the code (in its PSM format - Platform Specific Model) to drive the performed transformations. This function is applicable to the legacy line of code. This level of granularity is particularly useful for isolating blocks of code and upgrade to a SOA service.
- A SOA reorganization by annotation for the existing code
- All PIM models - Platform Independent Model or - UML2 Blu Age are organized in a service architecture and a separation layer. The generated application will precisely be structured according to the organization of services in the modeling. Modeling enables to rearrange the services and their collaborations with flexibility and impact assessment. A change of organization (location of a service, exposure of a service) is carried out transparently and without requiring any coding.
- A chain of continuous integration to automate your upgrades and ISO functionality test
- All the tasks can be automated in the Blu Age chain of continuous integration. This ensures the compliance with good practices and the regular availability (batch and on-demand modes) of the versions of the application during its life cycle (migration, enhancement, new developments, tests).
The chain of continuous integration automates:
- the extraction of UML2 models
- the generation of the application
- the configuration management of UML2 models and the generated code
- the quality analysis of the product code
- the compilation and the packaging
- the deployment
- the tests
- Premium code and architecture
- The modernization of your application makes the modernized process agile and reduces its cost of ownership. Blu Age Modernization is committed to producing the application according to your quality standards and architecture, or to offering you a choice of standards widely used in the market. The knowledge base and code generation cartridges are continuously assessed with continuous automatic analysis of generated applications. These methods enable to achieve a particularly high quality of code and architecture.
- A single product for all your applications
- The knowledge base of Blu Age natively integrates several families of languages (COBOL, Pac, PL / SQL, client server, Java JEE, .Net ...) and can be easily extended to variants and other languages. This is achieved by modernization of code samples and association of ontologies of the knowledge base.
Architecture and Supported Architectures
Blu Age's knowledge base natively integrates multiple language families (Cobol, Pacbase, PL/SQL, Client server, Java JEE, .Net …) and can easily be extended to variants or languages not currently installed. This step is usually done by modernization of code samples as well as a “linkage” phase that links to the generic elements of the knowledge base.
The technological families that Blu Age Modernization supports are the following:
- Source Languages
- Cobol ANSI, Ideal, S-Cobol, Pacbase, Cool:Gen, RPG400, Delphi, Powerbuilder, Natstar, VB, PL/SQL, JEE, .Net
- Source Databases
- Hierarchical bases, indexed files, denormalized relational bases, relational bases
- Final Databases
- Oracle, DB2, MS SQL, Informix,MySQL, PostgreSQL, Apache Derby
- Final Frameworks
- Presentation: Spring MVC, Flex, ASPX, JSF RI, JSF MyFaces, JSF IBM, Struts, HTML5
- Reporting: Jasper, BIRT
- Services and web services: Spring, EJB3, .Net 4.5, CXF, Axis, WCF
- Inference and rules engine: Drools, BPEL engines
- Data Access: Hibernate, OpenJPA, Microsoft Entity Framework, HQL, JQL, SQL,stored procedures.
- Component Integration:.Java and .Net APIs integration
- Security and authentification: Spring security
- Final Application Servers
- Websphere, Oracle application server, Weblogic, Glassfish, JBoss, Jonas, WASCE, Tomcat, IIS.