NorthCarolina 120000QHDE Tags:  ca_cool:gen cobol eglcafe ca_telon ca_ideal vb adabas application_modernization rpg application_conversion application_transformatio... powerbuilder maestro natural 2 Comments 7,302 Views
The Application Transformation Blog is a forum for IBMers, customers and business partners to discuss the who, what , when, where , how and whys of transforming legacy applications written in VAGen, SmallTalk, I4GL, Natural/ADABAS, RPG, CA Cool:Gen, CA Ideal, CA Telon, Maestro, APS, Powerbuilder, VB, and other 4GLs to Rational Business Developer featuring EGL technology.
This blog should be used by customers who have spent huge sums of time and treasure developing custom applications that set them apart from competitors and optimally support their specific business processes. Yet when it comes to functionality and technology, these custom applications can quickly grow old and lose their value. So th ey need to find alternatives that leverage their investments.
Who is a candidate for Applicaiton Transformation?
Literally any IT organization running older legacy systems that are core to the business, not necessarily broken, but are on life support due to the software being in maintenance mode, a lack of skilled IT programming staff in the older language or an IT strategic direction is to move to a new , modern software development platform.
When is it appropriate?
That depends on the specific business need, for example:
Extending the application lifecycle
Transitioning to an SOA
New UI (User Interface) requirements - Web/JSF, Rich Client/Web 2.0
Improving agility and Increasing competiveness
Vanishing RPG developer skills - Consolidating development teams
Through maintenance, functional aging can be circumvented or at least significantly slowed. Most of the time, however, technical aging goes unnoticed until unreasonably high maintenance costs arise later on in the lifecycle; application agility declines; or the development platform begins dying a slow death. These are all indications that it's time to migrate an application to a new technological platform before its costs outweigh its benefits.
When they reach this point, companies often find themselves in a bind. They realize that it's not cost-effective to simply replace their legacy applications with modern standard software. And few can afford to continually rewrite all of their custom software to keep it up to date. Even if they can afford rewrites, companies realize that the money could be better spent on a more cost-effective approach to modernizing and migrating to the latest technical standards.
How do you approach application transformation? What's involved? Which technologies? Are there phases?
There are three main phases in any applicaiton transformation:
Discovery aNd Analysis(DNA)
Implementation, Testing and Deployment
From a technology perspective the target of all Rational Application transformations is Rational Business Developer featuring EGL technology. Embedded in Eclipse, EGL offers a modern, service-oriented language for the efficient development of different application types, including Web programs, database applications, Web services, and batch and high-performance servers for fast transaction processing. Thanks to the tightly knit integration in the IBM Rational tool chain, EGL development can be embedded in a professional development process or lifecycle -from requirements management to modeling and coding, to testing and deployment. EGL's ease of adoption helps facilitate the transformation of RPG applications. Because EGL is easy to learn, it enables RPG developers to transfer their valuable business know-how in just a fraction of the time it would take for those same developers to transfer to Java technology.
Where does it occur?
Some tasks can be performed off-site on secured servers - the initial DNA and actual code transformation. The actual code transformation is typically performed off-site on secured servers. An EGL Project or Projects would be delivered to the customer site for implementation and testing which can be performed by the application owner or a service provider. Other tasks must be performed on-site - Education & training, code remediation (if required), implementation and testing.
Who performs which tasks?
Depending on the legacy source code environment, IBM & IBM specific business partners will perform the analysis and code transformation. The code remediation (if required), implementation, testing and deployment can be performed by internal IT staff with or without assistance from IBM, IBM SI or IBM Business Partners.
None of this is trivial, but it is all doable. The best advice is to contact Ed Gondek at IBM Rational - email@example.com and start the discussion![Read More]
Our next release, Rational Business Developer 8.5, was announced on May 29 and will be available for download on June 15. More information on RBD v8.5 is included in the Rational Developer for System z 8.5 announcement letter, and it also received honorable mention in the Rational Developer for Power 8.5 announcement letter, as part of the RDi for SOA bundle.
RBD Version 8.5 is a relatively small release for RBD, primarily focused on maintaining compatibility with the Rational tools family and supporting newer versions of related software, including:
We've also implemented a few Requests For Enhancements (RFEs), including:
The 8.5 products are based on Eclipse 3.6.2, the same as the 8.0.x products. However, you cannot upgrade an existing RBD 8.0.x installation to 8.5; you will need to do a new install.
TheresaRamsey 1100004FVX Tags:  dynamic_loading history rational egl infobus rbd dojo 1 Comment 8,659 Views
If you are building a Rich UI application with Rational Business Developer, you'll notice there are a variety of widgets that appear on the palette for you to drag and drop unto your Design tab. However, there are a number of widgets, handlers, libraries, and more in the RUI and Dojo projects that don't appear on the palette. We don't want you to miss out on these useful tools though! So here's a little more information to get you more familiar with what's available.
In the Rich UI project, com.ibm.egl.rui, you'll find InfoBus, History, Loader, and MVC in addition to the widgets. InfoBus is a publish-and-subscribe mechanism that allows handlers to receive data when an event occurs. This type of mechanism is particularly useful for communication between handlers, such as knowing when data has changed, and keeping all the handlers up-to-date with the changes. History provides a mechanism to use the browser's Back and Forward buttons to show different 'pages'. Since web 2.0 applications differ from JSF apps by allowing you to update parts of the screen, you can control what on-screen content you identify as a separate page. Loader provides a way to dynamically load the pages of your application, reducing the load time and improving application performance. You can read more in the blog on Starting your large Rich UI application faster with Dynamic Loading. MVC stands for Model (data and logic to access), View (the user interface or UI) and Controller (the interaction between the UI and model). MVC is a common architectural pattern that allows you to isolate domain logic from the UI, allowing you to develop and maintain this separation for flexibility. For examples of using InfoBus and History, see the Rich UI technical sample project, com.ibm.rui.samples, linked from Samples page of the product Welcome screen. The tutorial "Create a mortgage application using EGL Rich UI" located in the product Help also uses InfoBus.
In the Dojo project, com.ibm.egl,dojo.widgets, you see a items such as ContextMenu, Dialog, TitlePane, and Tooltip. ContextMenu generally is invoked by a right-click, and like DojoMenu is made up of DojoMenuItems. Dialog provides a pop-up dialog that appears on top of the right of your UI and can contain a number of widgets. TitlePane provides a collapsible container with a title bar and lets you control where it appears open or collapsed and the time duration to animate the open and collapse. Tooltip is generally used for contextual help text and allows you to control the position and delay before it appears. The product help provides more information on each Dojo widgets as well as a very useful sample project, com.ibm.egl.dojo.samples, that shows each of the Dojo widgets in action which is also available from the Samples page of the Welcome. To show how the RUI and Dojo projects can work together, the ContextMenuSample handler uses InfoBus to track and display which menu items have been clicked.
We hope this blog has made you more aware of the capabilities beyond what appears on the palette. We hope you will explore the projects and samples mentioned, and even more importantly -- make use of these in your own applications.
TomBaranski 270004V3TM Tags:  rational build build_server rbd vse z/vse egl 1 Comment 7,562 Views
Did you know that there is now a better way to generate COBOL programs to VSE? Rational Business Developer (RBD) version 8 includes the new VSE Build Server, which has the following advantages over the existing FTP-based generation:
Below is a sample of the detailed information returned by the VSE Build Server:
Mon Nov 28 15:31:16 WST 2011 ************VSE Build Server Started************************** Mon Nov 28 15:31:16 WST 2011 Attempting connection to pthvse9 with userid <yourID> on port 2893 Mon Nov 28 15:31:16 WST 2011 Successfully Connected To pthvse9 (z/VSE 4.1.0) via VSE Connector Server 1.4 Mon Nov 28 15:31:17 WST 2011 About To Send File C:\Genout\VSE\CICS\DSERVER.cbl Mon Nov 28 15:31:17 WST 2011 Sending File To EGL.V8CICS(DSERVER.C). Mon Nov 28 15:31:17 WST 2011 File Transfer Succeeded Mon Nov 28 15:31:18 WST 2011 About To Send File C:\Genout\VSE\CICS\DSERVER.jcp Mon Nov 28 15:31:18 WST 2011 Sending File To EGL.V8CICS(DSERVER.Z). Mon Nov 28 15:31:18 WST 2011 File Transfer Succeeded Mon Nov 28 15:31:18 WST 2011 About To Send File C:\Genout\VSE\CICS\DSERVER.ppt Mon Nov 28 15:31:18 WST 2011 Sending File To EGL.V8CICS(DSERVER.PPT). Mon Nov 28 15:31:18 WST 2011 File Transfer Succeeded Mon Nov 28 15:31:18 WST 2011 Submitting job: C:\Genout\VSE\CICS\DSERVER.jcp Mon Nov 28 15:31:18 WST 2011 Job DSERVERJ.27816 submitted Mon Nov 28 15:31:24 WST 2011 Getting output DSERVERS.27816 for job DSERVERJ.27816 Mon Nov 28 15:31:26 WST 2011 Job DSERVERS Succeeded. Max Return Code 4. Duration 00:00:04 Mon Nov 28 15:31:26 WST 2011 Job Output Written To C:\Genout\VSE\CICS\DSERVERS.out Mon Nov 28 15:31:28 WST 2011 Getting output DSERVERX.27817 for job DSERVERJ.27817 Mon Nov 28 15:31:29 WST 2011 Job DSERVERX Succeeded. Max Return Code 0. Duration 00:00:01 Mon Nov 28 15:31:29 WST 2011 Job Output Written To C:\Genout\VSE\CICS\DSERVERX.out Mon Nov 28 15:31:31 WST 2011 Getting output DSERVERC.27818 for job DSERVERJ.27818 Mon Nov 28 15:31:32 WST 2011 Job DSERVERC Succeeded. Max Return Code 0. Duration 00:00:04 Mon Nov 28 15:31:32 WST 2011 Job Output Written To C:\Genout\VSE\CICS\DSERVERC.out Mon Nov 28 15:31:34 WST 2011 Getting output DSERVERL.27819 for job DSERVERJ.27819 Mon Nov 28 15:31:34 WST 2011 Job DSERVERL Succeeded. Max Return Code 2. Duration 00:00:01 Mon Nov 28 15:31:34 WST 2011 Job Output Written To C:\Genout\VSE\CICS\DSERVERL.out Mon Nov 28 15:31:34 WST 2011 VSE build succeeded Mon Nov 28 15:31:34 WST 2011 Disconnecting From Host Mon Nov 28 15:31:34 WST 2011 **********************VSE Build Server Finished************************
The VSE Build Server uses the VSE e-business Connectors to submit generated programs to VSE and report the results. To use the Build Server, you will need to install the VSE Connector Client on your RBD machine and configure the pre-installed VSE Connector Server on VSE.
The VSE Build Server is currently an opt-in feature that is activated by specifying an symbolic parameter in your build descriptor. Information on setting up and using the VSE Build Server can be found in the Rational Business Developer Generation Reference for VSE feature (SC19-3222-00).
bsvihovec 110000N29Y Tags:  rich_ui performance rbd rational widgets rbd8012 1 Comment 6,290 Views
Version 18.104.22.168 of Rational Business Developer includes multiple performance improvements for Rich UI applications. The following is a list of the improvements that were made, and a brief description of how these improvements may affect your Rich UI applications:
Dynamic Loading - Dynamic Loading allows an EGL Rich UI application developer to indicate which RUIHandlers should be included in the initial download of an application, and which RUIHandlers can be loaded 'on-demand' while the application is running. Loading handlers dynamically can greatly improve the start time of an application since it reduces the amount of content that needs to be sent to the browser before the application can be run.
Grid Layout -The Grid Layout widget has been optimized to improve rendering performance using the same techniques that were applied to the Data Grid widget in prior releases. In addition to improving the run time performance of the Grid Layout widget, the Rich UI Visual Editor has also been optimized to provide better performance when adding, removing, and relocating widgets within a Grid Layout. The updated version of the Grid Layout widget can be found in the com.ibm.egl.rui_4.0.0 widget project.
Rich UI Application Deployment - While RBD 22.214.171.124 was being developed, the Rich UI Deployment process was found to be re-generating handlers unnecessarily as they were being deployed. This bug has been fixed, and handlers are no longer being generated during deployment.
Improved Memory Management - While RBD 126.96.36.199 was being developed, a memory leak was found in the Job widget, which was causing the memory associated with the Job, and the part that declared the Job, to be released only when the browser was closed (e.g. tab or window). In a Rich UI application that creates 'anonymous' Jobs, this meant that the memory used by each Job, and the memory used by the RUIHandler instantiating the Job, was not being released when the Job was finished. This bug has been fixed, and a Job object is now released as soon as the Job finishes running. (Note: If a Job is declared as repeating, the memory associated with the Job will only be released when the Job is canceled or the browser is closed.)
With these improvements, your Rich UI applications should run faster.
TonyChen 120000B5CJ Tags:  rational rich-ui loading dynamic html egl deploy performance rui 1 Comment 9,912 Views
An EGL Rich UI application is normally deployed into a single HTML and downloaded to user’s browser as a whole when the application starts. There are times you may want to download code only when it is being called to reduce the initial loading size and to speedup the starting of the application. The Dynamic Loading feature gives developers control of when to load application code. The initial version of Dynamic Loading has been available on the EGL Café for about 2 years and now an updated, enhanced version is formally included in RBD 188.8.131.52.
A typical RUI application that will benefit
from Dynamic Loading is one that has a main RUIHandler which navigates to multiple
functions each is provided as its own RUIHandler. The EGL Dojo Sample application
is a good example of such application. In this blog, I’ll walk you through the steps
to turn Dojo Sample into a Dynamic Loading application and see how the initial
loading size is improved.
A typical RUI application that will benefit from Dynamic Loading is one that has a main RUIHandler which navigates to multiple functions each is provided as its own RUIHandler. The EGL Dojo Sample application is a good example of such application. In this blog, I’ll walk you through the steps to turn Dojo Sample into a Dynamic Loading application and see how the initial loading size is improved.
A quick look at Dojo Sample
You can get the Dojo Sample from Help->Samples menu in RBD. Gallery.egl is the main handler which provides the screen layout, header, footer and left navigation. When a button in the left navigation is clicked, the corresponding sample will be launched in the content area in the middle.
Turn Dojo Sample into dynamic loading
The showSample() function is responsible to launch sample, it checks for the text of the button being clicked and decide which sample handler to be instantiate and put to the content area.
function showSample(e Event in)
First, instead of use key word “new” to instantiate the sample Handler, we will use DynamicLoader.loadHandler() to load and instantiate the handler at runtime. You will have to use the quoted string to reference the handler name.
Each dynamic load is asynchronous. Next, you will write the listener function which responds to the load completion even and add the loaded handler instance into content area.
//The listener function
Register the listener function to DynamicLoader when the Gallery starts. The call to showDebugView() function is optional, debug view can display loading status which is helpful at development time.
With above changes to Gallery handler, the sample loads dynamically. Run the new sample application in Preview mode to see dynamic loading status in the debug view. To experience the performance gain, run the application in deployed mode.
Deploy the dynamic loaded Dojo Sample
In the EGL deployment descriptor, specify the handlers to load dynamically so that the code and necessary resources for these handlers are prepared for loading at runtime. Go to the Rich UI Deployment tab, select the new version of Gallery handler and click the Configure button in Dynamic loading setting section.
In the popup dialog, add the sample handlers which are going to be dynamically loaded to the list on the right and click finish to save the settings.
Now you are ready to deploy the dynamic Dojo Sample. After deployment, the HTML file size of the dynamic version is 367Kb which is nearly half of the static version which is 674Kb. If you consider the 280Kb runtime footprint for a RUIHandler, the improvement of initial load size is quite significant. The larger your application grows, the more benefit you’ll get from a dynamic loading infrastructure.
You find more details about the Dynamic Loading feature in the RBD 184.108.40.206 Information Center.
As most UI developers know, a grid is an effective way to display data. The EGL Rich UI DataGrid widget is introduced in RBD 8.0.1 as a powerful way to display data, plus enable common data handling in an effective and efficient manner. DataGrid inherits most APIs of the previous Grid widget such as behaviors. Additionally, a lot of powerful features are built into DataGrid. Let's have a quick survey of the new features using a diagram.
Built-in PropertiesDataGrid adds several useful built-in properties; most are shown in the visual editor's Properties view. If you click on the DataGrid in Design pane of visual editor, you can find the DataGrid specific properties in the "General" tab of properties view to control the grid's header, button bar, sorting, and checkbox column.
Some new features
In this example DataGrid, the scrollbar is disabled so it defaults to paging the data. Data can be edited inline, and a checkbox column is used.
This blog has covered just some of the functionality of the new DataGird. For more information, please refer to the Rich UI DataGrid page of the RBD information center.
We hope you try out this new DataGrid widget in your Rich UI applications! We think it has a lot of useful features. If you have ideas for improving the DataGrid, add a comment to this blog post and let us know!
Ji Yong Huang
If you're kicking yourself because you didn't attend the 2011 EGL Conference, Innovate 2011 is just around the corner (June 5 - 9 in Orlando, Florida). Innovate provides a great opportunity to learn about the latest and greatest technologies from IBM (and partners) for effectively developing software. Why attend?
To save $100 on your registration, use promotion code SYSZ (if you are a System z customer) or PWRT (if you are an IBM i or Power customer). Make sure to pick System z or Power as your top track preference when you register. For more information and to register, visit: www.ibm.com/software/rational/innovate/
See you in Orlando ...
After a few delays, Rational Developer for i for SOA Construction (RDi SOA) version 8.0 is here! Read the full announcement.
(Note: customers that get RDi SOA through AAS will have to wait until April 15 for the code to become available)
For those of you not familiar with RDi SOA, RDi SOA is the EGL development tool for IBM i shops. It includes tools for EGL, RPG, and COBOL development on i. It is made up of the following products:
The new version of Rational Business Developer is now generally available! As I explained in October, version 8.0.1 represents a major update, and has some very compelling new features, especially for those of you developing Web applications and services.
How to get version 8 ...
Either method works regardless of whether you have entitlement to the product or not (alternatively, you can download the RBD 8.0.1 parts from the PPA site). Once you install the trial, you can apply the version 8.0.1 license activation kit (or configure your floating keys). As always, post any questions to the EGL Forum.
Let me be the first to thank the great team of architects, developers, testers, and writers (spanning multiple continents) that put in long days (and nights) to deliver this new release!
Looking forward to your feedback (both good and bad) ...