© Copyright 2007, In

Editor's Welcome

Hey there. Julyunbelievable. It’s here alr(heck, it’s almost over!) Whappened to the concept “time passes slowly”? Nothe EGL world, of that wecertain. - continued

In this issue:

• EGL Customer Adescription of the

• Text Reporting EGL dev-manager

• Application Tranmigration of COBO

• Best Practices: article by Jim Li o

• System i Niche • System z Niche

been too busy of • Talking JSF - EG

development tips • Thinking SQL - E

techniques on SQ• EGL Language T

- okay, possibly - • EGL in the News

and media events

The Tech Corner is publishResearch Triangle Park DeInternational Business Ma

nd

EGL Tech Corner – Issue #2 – 2 Quarter, 2007

ternational Business Machines 1

… eady hat

of t in are

Product Line Manager

On April 24th we announced and released to the market the Rational Business Developer Extension V7.0, the new EGL delivery product - continued

pplication – This section features a detailed CA State’s DOT work with EGL for V7 of EGL – an article by Vince Petrillo, , on V7 RBDe/EGL batch reporting features. sformation to EGL – an article on the L/RPG/VAGen/Natural to EGL

EGL and ClearCase Integration – an n team development/source management – What’s new with EGL in the System i world – repeated from last issue – Mark Evans has late… he promises something for the fall ☺ L and Java Server Faces web page and techniques GL and RDBMS access (technical tips and

L coding) ip of the Month - Something you probably didn't know about EGL - Articles, publications, conferences, classes

ed by the IBM Software Solutions Division, velopment Laboratory. © Copyright chines Corporation 2007. All rights reserved.

Featured Business Partner **

MORPHEUS LTD – “Award Winning Web Solutions” www.morpheus.co.uk

Morpheus, is a UK IBM ‘Certified for e-Business’ Partner and was established in 1997 to provide professional online solutions. The services provided span the full breadth of e-business, including consultancy, e-commerce implementation, application development, secure hosting, support and training. Now celebrating ten years of business, Morpheus has been a recipient of the IBM ‘Rising Star’ Software Award 2003, the IBM Solution Excellence Award for e-Commerce 2001 and also Channel magazine’s Solution Provider of the Month accolade, which rewards companies who are ahead of the game in e-commerce. Morpheus was voted Business of the Year in the Royal Borough Business Excellence Awards 2004. continued…

** Note – Each quarter a different EGL technical business partner will be featured in this Tech Corner from around the globe.

© Copyright 2007, International Business Machines

Business Partner of the Month - continued f In 2006 Morpheus was awarded the contract with one of the Unitesolution for obtaining quotations and completing applications at auwould be quick and easy to use with a secure login facility that inteaccordingly. The site ensures the removal of all manual processingbank is now able to collect payments directly from their dealershipstatements are available online to reduce paper and postage costs Multiple layers of security were built into the site to ensure appropadministrator or the Bank’s personnel. The site has been built witharchitected to handle in excess of 75,000 applications. Another customer requesting Morpheus’ expertise in EGL has beenand purchase orders for repair work via the web without changing customer satisfaction being up and costs are down. Morpheus’ developers have substantial experience in JAVA developteam they saw the opportunity of using EGL as an advantage for thEGL include integration with existing RPG applications, web-enablindevelopment of Java skills and a way to support clients as they mo

One of the Morpheus developers using EGL is Lewis Keen. work: Having joined Morpheus with little experience in developinglearning curve. However, once I had mastered the Rational Applicaproductive member of the development team within a short space provides a simple drag-and-drop interface that allows for quick pagvalidation and business logic which is handled efficiently through E

EGL has also provided a common ground with customers who havecommunication of their requirements and has allowed for quicker d

Using RAD has also provided the opportunity for me to work on othas WebSphere Commerce. Due to the familiar interface I have beegood use, whilst further expanding my knowledge with WebSphere Summary Our vision is to exceed the expectations of the client, combining anwhilst focusing on the business need. As a recognized ‘Investor inand rewarding environment, which will challenge our team and briour clients deal with highly skilled professionals with a genuine inte Bleddyn Williams Technical Director has written a detailed accounthttp://www.morpheus.co.uk/assets/PDFs/MorpheusEGL.pdf

rom cover page...

d Kingdom’s leading banks to develop a state of the art web tomobile dealerships. It was vital for the bank that the site rprets which client is using the system and brands the site and the built in validation has helped to avoid errors. The

s bank account or via paperless direct debit. Commission .

riate access is available for general users, dealer IBM’s Enterprise Generation language (EGL) Tool and is

a leading Insurer requiring a system to streamline quotes their back-end application. Completion has resulted in

ment and after extensive training from the IBM Rational eir customers that use RPG developers. The advantages of g legacy applications, enabling clients to accelerate the ve forward along a JAVA roadmap.

Here is what he has to say about his EGL commercial web applications, I expected EGL to be a steep tion Developer (RAD) interface I was able to become a of time. The integration of EGL with JSF through RAD e design, and has allowed me to concentrate on the GL.

had past experience with RPG, allowing for better evelopment and training.

er projects within Morpheus which use IBM products, such n able to use what I have learnt from developing in EGL to and in JSP development.”

understanding of key technology and industry directions, People’, Morpheus place an emphasis on creating a positive ng out the best in their creativity. This in turn, means that rest and enthusiasm in their fields of expertise.

of EGL and can be viewed at

2

© Copyright 2007, International Business Machines 3

Editor's Corner - continued from cover page...

So - the theme of this issue is RBDe and EGL Version 7. Yes – Rational Business Developer extension. Yes Version 7. We pause a second to take a breath before diving in to this What’s in a Name?

• Rational – okay that’s easy. Branding! IBM knows a little about such things. • Business Developer – easy too. EGL has always been about business – not bits and deep tech. But about solving

business application problems; efficiently, productively, uncompromisingly – and with you – Business Programmers – doing the work. This is as opposed to the über-geeks (deep J2EE programmers) doing highly technical – and necessary, but perhaps like using an electron microscope, to study things that could be done more easily, quickly (and cheaply) with an optical microscope.

• Extension – this is final part of the product name means that EGL is now an official plug-in extension to the eclipse-based products:

o RAD - Rational Application Developer o WDSC – WebSphere Developer Client Studio – standard and advanced edition o WDz – WebSphere Developer for Z series

RBDe version 7 does NOT stand-alone at launch – and depends on one of the above three platform-tools. So, that’s what’s in the name. Where Can I Learn More About RBDe? From a variety of sources – first, the official IBM site-links

• RBDe DeveloperWorks: http://www-128.ibm.com/developerworks/rational/products/rbde/ • ibm.com product page:

http://www-306.ibm.com/software/awdtools/developer/business/

• And most importantly, where can you get the trial bits page: http://www-128.ibm.com/developerworks/downloads/r/rbex/?S_TACT=105AGX15&S_CMP=DLMAIN

Additionally, you will be able to take Distance Learning in RBDe, beginning in June. We finally have a DeveloperWorks page for sign-up - http://www-128.ibm.com/developerworks/offers/lp/r/rbdetws/#eglbd Interest in RBDe/EGL Version 7 is actually hotter than a jalapeno. And to assist you in learning about Version 7’s new features and functionality you can sign up for distance learning: http://www-128.ibm.com/developerworks/offers/lp/r/rbdetws/ - as well as go to the above web-sites, and read product announcements, data sheets, etc. Why? Here’s a really, really, really (that’s 3 reallys) brief – and totally incomplete synopsis of new features introduced in RBDe/EGL Version 7:

• Product overall: o Faster run-time code - generated o Smaller product and project footprints o Enhanced project-level re-factoring capabilities o Simpler product installation and updating o Enhanced documentation

• Support for: o Enhanced and comprehensive services (SOA) support – including COBOL, CICS, etc. o Model-Driven Development – UML to EGL o Enhanced inline exception handling support – new, deep and rich language features o Rich Client Application support o Portal Server and Portlet support o Built-in Text Reporting language features (see article in this issue) o AJAX, and new JSF controls (Dynamic Data Graphing, Tree controls, etc.) – and JSF functional support for

essential form controls (Calendars, Spinners, etc.) o Dozens of new language and editing/tooling features (see article in this issue for one)

Example: If/Else/End selection in the editor Boolean primitive type

Well, that’s it for starters (I’ll probably get clobbered by Stefano for leaving some major enhancements out). Anyway – hope to see some of you in the August Distance Learning Class…. Jon Sayles, jsayles@us.ibm.com

© Copyright 2007, International Business Machines 4

Product Line Manager’s Corner - continued from the cover page...

Some of you may have read the announcement letter, and some may have tuned into one of the several Webcasts that followed our product launch, so I will defer you to our web sites and literature for details about the new product. What I would like to do in this short article instead is to reflect on the motivations for this new go to market strategy, and on the market dynamics we are beginning to observe on the wake of the announcement. Prior to the availability of Rational Business Developer V7.0 EGL was marketed as an integral component of all the primary IBM development workbench offerings, namely Rational Application Developer V6, WebSphere Developer for zSeries V6 and WebSphere Development Studio Client. Although the original intent of this packaging strategy was to pervade as many IBM Customers development shops with EGL technology by putting it at their fingertips regardless of the development workbench of choice, the actual effect of this choice was quite the opposite. Being one of the innumerable "features" of another product made it very difficult to identify a specific market opportunity for that product as it related to just one of it's features: from a marketing messages standpoint the EGL value proposition never surfaced sufficiently, and the sales channels were unable to perceive their opportunity to sell the product on the specific merits of just one of it's features. On the other hand, when sales of the EGL hosting products were driven by the EGL value proposition, it was very difficult, if not impossible, to relate the product revenue back to EGL making it hard to monitor business performance of the IBM investment in EGL technology. In a few words, EGL embedded into other products was hard to market, to sell and to monitor business performance hindering its overall business case. In addition customers, who were not interested in EGL and bought the hosting product on other merits, developed a perception that they were buying and paying for unneeded capabilities. All these considerations led to the new packaging strategy of delivering EGL technology as a separately purchased and separately installed feature or plug-in extension. The very existence of a new product in the IBM Rational portfolio has the positive effect of improving the allocation of marketing and sales enablement resources to the EGL technology, while significantly simplifying business performance tracking. Being an actual product legitimizes marketing launch plans, with focus on press and analysts, production of marketing collateral and content syndication, sales channel enablement plans and execution, and many other important initiatives that contribute to raising the visibility of EGL in the marketplace and within the IBM corporation. The product-ization of EGL is also beneficial because it provides us a more disciplined framework for identifying the specific target markets with the relative go to market strategies. Clear identification and quantification of the opportunity in specific target markets helps us in effectively prioritizing our Research and Development investment in specific product capabilities that cater to those markets. EGL is currently well positioned to be the premier IBM solution for the Infomrix 4gl install base, for the VisualAge Generator and Cross System Product install base, for those Customers looking for Application Transformation and Modernization solutions, and for Customers who are either new to development of Web and SOA oriented solutions, or looking for more productive alternatives to their current capabilities, particularly those deploying to System i and System z. Following the launch of Rational Business Developer v7, we are beginning to see an unprecedented interest in EGL in the target markets we just mentioned: for example, our Distance Learning program, which offers free web based education workshops for Rational Business Developer Extension v7, is already overbooked just a few days after opening registration, the number of requests for EGL briefings is skyrocketing, our worldwide team in the past two months has been involved in literally hundreds of Customers interactions and the developerWorks Rational Business Developer Extension Technical Briefing has been offered in 3 worldwide locations and there are requests outstanding for 6 more in the rest of 2007. These dynamics are very encouraging and we expect the momentum to grow exponentially as our strategy to mainstream EGL technology in the marketplace, which includes submission of EGL to industry standard bodies for standardization of the language, providing free access to an EGL software developer kit and other grass roots nurturing initiatives takes hold. Stay tuned for many new exciting features and for a bright future for Rational's strategic cross platform rapid development solution! Stefano Sergi - IBM Software Group, Rational - EGL Market Manager, sergi@us.ibm.com

System i Niche EGL and System i - Update

© Copyright 2007, International Business Machines 5

It has been a busy couple of months since our last edition of this newsletter. During that time a great deal has happened in the Rational for System i organization with IBM. During this time period many of the System i development tools such as the compilers (RPG, COBOL, C, C++), ADTS (SEU, PDM, SDA, RLU, DFU), WDSC (Standard and Advanced Edition), and the WDHT were transferred from WebSphere to Rational along with the development teams you have known for years. We just attended the US COMMON conference in Anaheim and met many System i developers where Linda Cole and Claus Weiss presented Rational Business Developer Extension (EGL). These sessions were well attended and well received by the attendees who clearly saw the benefits of EGL development as the tool of choice to develop modern new applications integrating with and leveraging existing RPG and COBOL applications. Additionally we have seen a major influx of new System i customers trying and adopting EGL as their path to modern system development. Where some of you who have been working with EGL for a longer time than others may have felt you were alone, I am pleased to tell you that the number of customers and developers adopting and integrating EGL (via RBDe) is growing a exponential rates. For a couple of years now, I have been telling customers and anyone who would listen that EGL and the RBDe is the modern language and toolset for business system developers who need to focus on solving business problems and avoid the technology. You are proving that I have been correct. You have been telling us that you love System i but are concerned about the fact that your applications are dependent upon a single platform and technology (i.e. the i5 machine and i5/OS operating system running RPG or COBOL). We are finding that as customers adopt and transition at their own pace to EGL, the value proposition of the i5 increases instead of diminishes. The i5 has the lowest total cost of ownership, is secure, scalable, and reliable totally complimenting EGL and modern platform independent applications. We are promoting the idea of flexibility in terms of application modernization. We are suggesting that we can tell you that it is IBM's direction and strategy to encourage you to move towards an SOA based environment and adopt EGL via Rational Business Developer as your language of choice for modern development. We are also stating that we cannot provide you with a specific roadmap without knowing your business objectives, staffing constraints, or budget. Instead we are offering a series of modernization options that IBM Rational representatives can work with you to create your own customized roadmap. We offer four key options to modernization that we think you should review and consider. Use one, several, or all of these options depending upon your requirements:

Option 1: Rapid Web Enablement -- Use RBDe to begin to develop web applications that compliment your existing install base of RPG or COBOL applications. Access your System i database or call existing RPG or COBOL programs. Option 2: Service Adapters -- Many customers have 3rd party applications or their own applications with well defined API's or user interfaces. Creating EGL "Service Adapters" via EGL Services or Web Services and integrating these services with new applications developed in EGL is another popular strategy. Option 3: Refactor Existing Code -- in this approach we recommend using Databorough Inc's X-Analysis and X-Migrate products in conjunction with EGL and RBDe to refactor existing monolithic RPG or COBOL programs into an MVC architecture that separates the 5250 UI, business logic, and database access into separate programs and then leverage your business logic with EGL (continued on next page…)

© Copyright 2007, International Business Machines 6

System i Niche EGL and System i – Update - continued Please note that we do not advocate any one of these approaches and suggest that you must choose your own strategy using one, many, or all of these options as best fits the needs of your business. Our Rational representatives and consultants can assist you in developing and pursuing your modernization strategy. Please feel free to share your thoughts and ideas on leveraging EGL with us, we always welcome you input on how we can deliver better tools to assist you. Please note that we are committed to continuing to support RPG, COBOL, and their related tools while integrating EGL into your environment. I hope you are as excited as I am about a bright and challenging future for System i and Rational software.

Bob Cancilla IBM Software Group, Rational Product Market Manager - Rational Tools for System i and z

EGL Consultant of the Quarter – Aaron Allsbrook

Aaron Allsbrook, IT Specialist, Software Services. Aaron began working with IBM as a CO-OP with the Visual Age Generator development team implementing COBOL to VAGen automation tools. In 2002 he began fulltime employment as a developer on the IBM WebSphere Studio Enterprise Developer product working on both EGL performance testing and the product install process. From there he moved to the Rational Application Developer Web Tools team supporting development of Struts tooling and the Web Diagram Editor during both of the version 6 and 7 releases. In October of 2006 he transitioned from Development group into ISSR. Since joining ISSR he has worked the Analysis Design and Construction space of the Rational brand. In addition to offering sales support and customer education his major projects include:

- Implementation of web prototyping process enabling business analysts to quickly build sample web application tied to requirements for rapidly gaining stakeholder approval.

- Migration of customer UML model transformation from DPTK and UML 2.0 to JET2 and UML2.1 - Legacy documentation process in collaboration with Global Business Services ARC tool to reverse engineer COBOL

applications into a UML model showing program relationships and execution flow. These models will ultimately lay the groundwork for a future SOA initiative.

In March of 2007 Aaron participated in the EGL Residency in Raleigh NC. With the enablement from the event he was able to move immediately into a lead EGL architect role to support a Global Business Services project working with an ISV customer to migrate their large System I COBOL application to a flexible system with a modern web interface. The activity involved POC work to demonstrate EGL capabilities, define a staged modernization approach, and educate the customer in the language and tool interface.

System z Niche EGL and CICS - Threadsafe Execution Support

EGL now supports and allows enablement of CICS Threadsafe execution through an enhancement to the EGL COBOL Runtime. This enhancement can be obtained by installing the base Rational COBOL Runtime for System z V6.0.1 product or by installing the PTF UK08442 on the Enterprise Developer Server for z/OS V5.0 product. Your existing generated COBOL programs do not require regeneration to take advantage of this enhancement. So what is CICS Threadsafe execution? As of CICS Transaction Server V2.2, CICS added the ability to reduce the switching between the CICS and DB2 address spaces when DB2 calls were made by the application program. By reducing this switching, the overall amount of CPU time used can be reduced. In fact, one COBOL generation customer reported they were getting up to 25% CPU time reductions by taking advantage of this new ability of CICS. However, the programs and all the calls it does have to be Threadsafe and now EGL is. For more information on CICS Threadsafe and what it means, please see the following IBM Redbook abstract called CICS Threadsafe for CICS

Mark Evans - Mark is VisualAge Generator Product Manager. He has a 2nd job in the EGL ECO System team - as specialist in COBOL generation, CICS, mainframe connectivity and VAGEN Migration.

© Copyright 2007, International Business Machines 7

© Copyright 2007, International Business Machines 8

Talking JSF Tab Controls in V7

There are literally dozens of incredibly cool, new JSF component features in v7 for you to take advantage of. In future issues of the Newsletter we’ll cover topics like: AJAX, dynamic graphing, and the new EGL annotations for selection controls. We Start With V7 Tab Control Enhancements Some of you might be (or might want to be) using Tab Controls on your web pages… okay, a lot of you might. That’s because tabs are a very attractive mechanism of organizing and presenting related information. They’ve been a great web U.I. metaphor for a very long time, and are particularly well suited to consolidating 3270/5250 screen data.

JSF/V6 really just introduced the Tab control to EGL/JSF web page development teams as a viable. V7 takes JSF Tab functionality to a whole new level of complete-ness and coverage, providing property-based options for:

• Orienting Tabs horizontally (traditional tabs, not shown here) or vertically-orienting tabs (see above) – and to nest logically related sub-tabs in a hierarchy (you can see that Customer Orders – Cancelled is presented as a child tab, of ALL Customer Orders.

• Allowing you to assign icons to tabs • Allowing you to fire off EGL JSFHandler (previously PageHandler) functions, upon entry and exit of individual

panels within a tab (allowing you complete control over the tab panel’s behavior) • Dynamically assigning Tab names, Tab icons, and dynamically rendering (hiding/showing) a tab

Nearly all of the new RBDe, EGL and JSF functionality can be discovered by taking the free Distance Learning classes: http://www-128.ibm.com/developerworks/offers/lp/r/rbdetws/ - sign up for the August session today (before they fill up!) Jon Sayles – member of the EGL ECO-System Team, can be reached via eMail: jsayles@us.ibm.com

Thinking SQL Version 7 Data Tools

The RAD/WDSc/WDz Version 7 products unleash a powerful arsenal of product tools and features for working with relational data. They’re called the “Data Tools” and are available under the Data Perspective, through a standard database connection (see the Database Explorer below). Some of the same tools that were available in the V6 products are still here, but there are an exceptional number of new graphical development options, such as:

• Relational Table Editor – add new rows, modify row values (including inserting nulls), delete rows, through a graphical editing facility (see above)

• Diagrams – Produce a Data Model (Entity/Relationship diagram) of a set of selected tables • SQL Query Builder – Create complex SQL Queries through a graphical building tool And all of the v6 options, including (but not limited to: SQL scrapbooks - for testing your SQL prior to making it an EGL function, Table DDL generation, Table sample contents (a snapshot of your relational table data), etc.

© Copyright 2007, International Business Machines 9

Jonathan Sayles is a member of the EGL ECO System team.

© Copyright 2007, International Business Machines

EGL Language Tip of the Month EGL V7 – Concatenating + Redefining with “as”

In Version 6 (and before) of EGL, redefining or casting data variables on-the-fly generally required you to move values to temporary holding areas and fields of a neutral datatype (NUMC, etc.). Very 90’s. In Version 7 you still concatenate strings (and char data fields) in EGL using the + (plus) sign fldOut1 = strfld1 + strfld2; //concatenate fields And (like Version 6) you can still use a “work-around” technique to redefine or “cast” numbers and dates, times, etc. to strings by simply adding a ""+ to the beginning of the expression fldOut1 = ""+numField + strField; //conca enate with numeric field

But in Version 7 you can also use an AS operator, to redefine a field as another type dynamically within a function (see Content Assist options) Examples //Concatenate a numeric field as if it were a string strFldOut = numField as string + strField;

//Perform math on a string field if it is numeric numFldOut = strField as int + numField;

Enhanced Concatenation and mathematical Op It was inevitable ☺ After years of “old school” coding conventions, the EGthe “dude-programmers” and introduced the += short-hand notation for sto state the following:

mmmyyyVVVaaarrriiiaaabbbllleee +++=== sssooommmeeeOOOttthhheeerrrVVVaaarrriiiaaabbbllleee;;; As opposed to the traditional, or as many considered far less “cool”: mVariable = myVariable + someOtherVariabl

+= works with strings (concatenation) and mathematical operations

Jonathan Sayles is a member of the EGL ECO System team.

t

10

erator - introducing +=

L language architects finally caved in to pressure from tring concatenation (DUDE!) And you are now allowed

e;

: += … -= … *= … /=

© Copyright 2007, International Business Machines 11

EGL IN THE NEWS

EGL Articles - Note there are really far too many articles being published on EGL each month to mention them all. We will post a few links with each issue of the Tech Corner

• CHCS (System i) Case Study- Community Health and Counseling Services accelerates delivery of HIPAA-compliant medical software with EGL

• Impire AG Case Study– IMPIRE AG scores with live-action sports content powered by IBM Information Management software, powered by IDS and EGL.

• Nordisk Copyright Bureau– Case Study - EGL Helps NCB Leverage Existing Expertise and Systems to Enable Customer Self-Service

• Egypt Ministry of Interior uses EGL to Rapidly Web-enable Key Legacy System - A formal study of how EGL saved over 15 branches of a major government agency time and money in software development and use

• EGL Overview- In this article learn about EGL if you're new to the language. • Inside Enterprise Generation Language - a System i article on EGL by Bleddyn Williams (Morpheus.co.uk – this

month’s featured B.P.). Bleddyn is an internationally recognized thought leader in software development • Research Report – a white paper produced by an independent consulting company on EGL’s value proposition

for mainframe shops (with an emphasis on SOA)

EGL Distance Learning Classes - Note that the all classes are taught using RBDe (version 7) software, and are free. To enroll for the August class click the link. To enroll for September, send an eMail to Jon Sayles: jsayles@us.ibm.com

• August Distance Learning – (click to enroll) http://www-128.ibm.com/developerworks/offers/lp/r/rbdetws/ o RBDe, EGL, SOA, SQL, Calling Java - August 10th o EGL, JSF, AJAX Web Project Development – August 28th

• September Distance Learning – the above link will be transferred to the September class after August closes o RBDe, EGL, SOA, SQL, Calling Java - September 25th o EGL, JSF, AJAX Web Project Development – October 9th

EGL Conferences and Events • Ongoing RBDe and EGL Tech-Briefings – coming to a town near you, soon! • Gateway College - EGL Technical Training and Symposium – Gateway is an IBM Academic Initiative - System i

College and will be offering the first EGL class for college credit this Fall. This is an evening class and starts August 28. For additional information go to Gateway's web site: www.gtc.edu/systemi or email Jim Buck - jbuck1@wi.rr.com. This class is part of Gateway's WebSphere Advanced Technology Certificate which is geared toward professionals who want to update their skillset using IBM's latest WebSphere software.

• System z Technology Roadshow - Learn how to take advantage of EGL, RBDe and other IBM software • EGL/SOA Teleconference– Ongoing webcast by Stefano Sergi, that describes the RBDe/EGL value proposition • EGL Modernization WebCast - an ongoing webcast that describes how to accelerate your business solution

delivery by simplifying and modernizing your applications with IBM Rational Business Developer Extension

EGL Links • The EGL Zone on IBM's Developer Works - the primary source of EGL information, worldwide, containing white

papers, publications, documentation, code examples, links to the product and much more • The EGL Technical Forum- The place to post technical questions and get technical answers • EGL Product download Links – where to get RBDe/EGL, and RAD trial software

EGL Contacts • Stefano Sergi – Product Line Marketing Manager • Omkar Nimbalkar- Manager of the ECO-System team. eMail Omkar with questions about engagements, classes, PoCs and projects, etc. • Jon Sayles – Editor of this newsletter, and general EGL support person

EGL Featured Application VWIX (Vendor WIC Information eXchange)

Women, Infants and Children (WIC) is a federally funded program, administered in California by the Department of

Public Health. WIC provides healthy foods to participants in some of the most critical years of life. WIC participants can redeem their Food Instruments (FIs) at any WIC authorized grocery store in California. In a typical month, over 3,600 grocers in California have the opportunity to accept about 6.5 million FIs from approximately 1.37 million WIC participants in exchange for these healthy foods. To be reimbursed, these grocers are required to provide WIC with the FI serial numbers (or, check numbers) before submitting the actual FIs to their bank for payment. To this end, VWIX was born. VWIX allows authenticated users to send FI serial numbers to WIC. This web application enables users in two ways. First, users can upload files from their computer. Second, users can enter individual FI serial numbers via a web page. VWIX was developed using RAD 6 and EGL. VWIX is hosted via WebSphere Application Server (WAS) on z/OS and uses DB2 as the database. This development/deployment environment posed many technical challenges. A few of them are noted below. How do you implement custom form-based authentication? Form-based authentication is relatively straightforward. It’s also a fairly limited option out of the box. However, you can implement custom authentication logic and achieve more flexibility in what happens at the end of the authentication process, if you implement custom form-based authentication. Custom form-based authentication allowed us to do the following:

• Execute logic conditionally, based on the operating system. • Store the User ID and “operating system” in session variables for later use. • Implement password-change functionality. • Redirect to custom pages, depending on the authentication outcome.

If your web server is at one data center and your database is at another, how do you access your data? In the VWIX architecture, WAS is hosted at one data center and DB2 is at the second data center, so we didn’t have the option of making calls to the database directly. Web services were not an option at the time, so we had to figure out another way to get to our data. We decided to create two COBOL/CICS programs. ProgramA is deployed to the “WAS data center”. VWIX is aware of this program only. ProgramB is deployed to the “DB2 data center”. ProgramA calls ProgramB via CICS Transaction Gateway. Programs A and B pass data back and forth via COMMAREAs. We made an EGL program that calls ProgramA. It’s a simple program that takes a record parameter defined the same as the COMMAREA in the COBOL ProgramA. package programs; program CallCOBOLprogramA type BasicProgram (awork COMMAREA) { throwNrfEofExceptions = yes } function main() try call ProgramA awork; onException // exception handling logic goes here end end end record COMMAREA type basicRecord 05 InputParm CHAR(2); 05 OutputParm CHAR(2); 05 Data CHAR(4); 05 Filler CHAR(31992); end

© Copyright 2007, International Business Machines 12

EGL Application of the Month VWIX (Vendor WIC Information eXchange) - continued For VWIX to know how to call ProgramA, a new CallLinkPart was added to the eglbld file. See below.

How do you temporarily save large amounts of data from multiple HTTP posts, before it’s permanently saved? One VWIX web page facilitates “heads down data entry”, allowing users to key multiple sets of serial numbers and review the data before actually saving the data permanently (see picture below). So, while users post form data, and before they decide they are done, the data must be temporarily saved somewhere. Users can enter up to 300 FI serial numbers per grocer. Users can enter multiple grocers before saving their data (So, logically this equates to a set of grocers, each of which contains a set of serial numbers). Since our data was not on our “WAS data center”, the overhead of saving data temporarily to DB2 tables seemed too much. Also, the I/O overhead of saving data to local files seemed too much. We ended up saving this data as “an array of arrays” in a Session variable until the user chooses to submit the data. This presented another challenge. In WAS, you must use arrays judiciously, or run the risk of encountering memory and performance problems. We found that we could manage the problems by dynamically increasing array sizes only when necessary.

© Copyright 2007, International Business Machines 13

© Copyright 2007, International Business Machines 14

EGL Application of the Month VWIX (Vendor WIC Information eXchange) - continued How do you save files dynamically created at run time, instead of saving directly to the database? Users are allowed to upload and save files via FTP, independent of the website. One of the business requirements is that the original files be saved “as is” and the website needed to mimic this same file-based model. We needed to take form-based input and dynamically create files from this input. EGL is designed to easily access databases and static files. It is not designed to easily write to files created dynamically at runtime. However, it is extensible enough to readily access Java classes. We wrote and implemented a custom Java class. This class is called from the EGL pagehandler and writes files from our collected form data. To write to the file system successfully, this class must know the operating system on which it’s running. How do you force the EGL onPageLoad event to be triggered every time a page is accessed? We were initially confused by the behavior of the EGL onPageLoad event. We expected this event to occur every time a page was requested. Instead, the default behavior is different. This event only occurs upon the initial loading of the page into memory. We had business logic that should be executed every time the page was accessed. To make sure the onPageLoad event was executed every time, we implemented 3 caching directives (meta tags) in the corresponding JSP page.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <%-- jsf:pagecode language="EGL" location="/EGLSource/pagehandlers/mypage.egl" --%> <%-- /jsf:pagecode --%> <HTML>

<HEAD> … <META HTTP-EQUIV="Pragma" CONTENT="no-cache"> <META HTTP-EQUIV="Pragma" CONTENT="no-store"> <META HTTP-EQUIV="Expires" CONTENT="-1"> …

If you can’t redirect from the EGL onPageLoad event, how do you accomplish such a redirect? *** Based on the certain results of business logic, we wanted to redirect from a given page before it was displayed. The EGL onPageLoad event does not allow redirection. To accomplish our desired redirection, we implemented the logic at the top of the corresponding JSP page. See below. <% String newsURL = "/News.jsp"; String anyNews = (String) session.getAttribute("anyNews"); if (anyNews == "YES") { session.setAttribute("anyNews","NO"); try { response.sendRedirect(newsURL); } catch (java.io.IOException ex) { // exception handler here } catch (Exception ex) { // exception handler here } } %> *** Editor’s Note – in version 7 you can now forward to URL – out of the onConstruction() – equivalent to onPageLoad() function.

© Copyright 2007, International Business Machines 15

EGL Application of the Month VWIX (Vendor WIC Information eXchange) - continuedUsing the JSF FileUpload control, how do you restrict file type and file size? VWIX allows users to upload a file via a web page. We used the JSF FileUpload component to accomplish this. We were challenged to restrict the file size and file type. Finding no good way to do this on the client side of things, we implemented server-side EGL code. We tested the file name as follows: selFile string; //Bound to FileName property temp char(80); selFile = strlib.clip(selFile); temp = selFile; while (i < strlib.strLen(temp)+1) if (selFile [i:i] == "." ) if ((i + 3) < strlib.strLen(temp) + 1) if (selFile [i:i+3] == ".txt" ) sendFile = "Y"; else errorMessage = "File '" + temp +

"' is not a .txt file. Only .txt files " + "can be accepted.";

sendFile = "N"; end else errorMessage = "File '" + temp +

"' is not a .txt file. Only .txt files " + "can be accepted.";

sendFile = "N"; end end i = i+1; end //end-while We tested the file size as follows: j bigint ; fileBlob blob; //Bound to File Value property j = loblib.getBlobLen(fileBlob); if (j < 1); // Check for empty file errorMessage = "File " + temp + " does not exist or is empty"; sendFile = "N"; else if (j > 390250 ); // Check for too large of file, 30,000 rec errorMessage = "File " + temp +

" is greater than the 30,000 serial number limit"; sendFile = "N"; end end How do you solve the problem of user “fast clicking” on one or multiple buttons on a page? Various strategies have been documented for mitigating the risk of users quickly clicking on buttons and submitting form data multiple times. These strategies all have their own pros and cons. We were looking for a server-side solution to the problem. In the JSP/JSF architecture, multiple requests are not queued up sequentially. In fact, they are not queued up at all, so the second request can come in early enough to disrupt the first one. Apparently the JSP/JSF architecture does not provide a thread-safe way to entirely solve the problem, so we resorted to the following client-side JavaScript strategy that significantly mitigates the risk. Basically, the form submission is delayed until the after the buttons are disabled.

EGL Application of the Month VWIX (Vendor WIC Information eXchange) - continued <SCRIPT type="text/javascript"> var hX_pageDone=false; var hX_submitButton; function bodyOnLoad() { var form1 = document.getElementById("form1"); form1.autocomplete = "off"; } // Ask the user to wait for a response from the server and also // prevent them from continuing to click after the request has

// been submitted. function disableSubmit (thisObj, thisEvent) { // Stage the disabling of the buttons for AFTER the form

// submission... hX_submitButton = thisObj; setTimeout("disableButtons()",10); return true; } // end disableSubmit function // User has clicked a button, requesting a response from the

// server. Prevent the user from continuing to click on buttons // before a response has been received.

function disableButtons () { var obj; if (!hX_pageDone) { // Disable the clicked button first. // Yes, all of the buttons will be "disabled" again

// below, but this statement makes the clicked // button disabled FIRST.

if (hX_submitButton) hX_submitButton.disabled = true; // These buttons are displayed unconditionally,

// so they must always be disabled here. form1.elements("form1:PrevPage").disabled = true; form1.elements("form1:NextPage").disabled = true; form1.elements("form1:MainMenu").disabled = true; form1.elements("form1:NextVendor").disabled = true; form1.elements("form1:Submit").disabled = true; // Optional buttons obj = document.getElementById("form1:Hdrtable2:0:button6"); if (obj) obj.disabled = true; obj = document.getElementById("form1:Hdrtable2:0:button7"); if (obj) obj.disabled = true; obj = document.getElementById("form1:Hdrtable2:0:button8"); if (obj) obj.disabled = true; obj = document.getElementById("form1:Hdrtable2:0:button9"); if (obj) obj.disabled = true; obj = document.getElementById("form1"); if (obj.tagName && obj.tagName.toUpperCase() == "FORM") { obj.onsubmit = "return false;"; } // Catch the user's eye immediately, hopefully

// slowing down the clicks... obj = document.getElementById("form1:Hdrtable1:0:textZ"); obj.outerHTML = "<span id=form1:text1 " +

"style=font-size:10pt;color:purple>" + "Please wait while we process your data...</span>"; hX_pageDone = true; } } // end disableButtons function </SCRIPT>

© Copyright 2007, International Business Machines 16

© Copyright 2007, International Business Machines 17

EGL Application of the Month VWIX (Vendor WIC Information eXchange) - continued How do you call EGL from Java? We have already seen how EGL capabilities can easily be extended by calling custom classes written in Java. At one point in the project, we needed to change our custom authentication logic to include database access. We had already figured out how to access the database with our EGL programs that called our CICS program. We are not Java experts and we didn’t want to reinvent the wheel via Java source code. Instead, we chose to create a Java wrapper around our existing EGL source code. Then, our custom authentication logic (Java) could use our existing EGL program to access the database. There’s a great article documenting this wrapper process at: http://www-128.ibm.com/developerworks/rational/library/05/510_java/

About the author Jason Doting is the founder and principal software developer of MCSD Group Inc (MCSDgroup.com). He helps organizations solve complex business problems by applying appropriate computer technology. Often, this includes development of custom, data-driven web applications on the IBM and/or Microsoft architectures. He is currently engaged with the California Department of Public Health in support of the WIC program.

From Lenexa Text Reporting for V7 of RBDe/EGL

RBD V7 is generating a lot of interest in the I4GL community. The I4GL customer base is finding that EGL is the answer for modernizing their applications. Some are exposing 4GL business logic as a Web application, some as a service. Some are taking advantage of the new GUI interface option for console applications. Others are merely taking advantage of the platform independence offered by EGL. One new V7 feature that is very exciting to the I4GL customers is the Text Reporting option. By providing this capability, EGL programmers can now easily create reports that are, in most cases, virtually identical to I4GL reports. Text Reporting was made available through the Enhancement Patch that has been posted on the developerWorks site and will be bundled with the RBD product starting with 7.0.0.3 (as of this writing, the current release). While Text Reporting was specifically designed to offer I4GL like reporting in EGL, this option may also be of interest to the broader EGL developer community where simple text based output is desired. It is especially easy to use for pre-printed forms or to generate flat files that are consumed by other applications. For reporting, Text Reports is built on the assumption that the report content is purely text and the font is a fixed width font. While reporting tools like BIRT and Jasper provide generation of HTML or PDF report files, they can require more overhead and interject more complexity to an application than is necessary when simple text output is all that is required. Since Text Reporting is modeled after the I4GL reporting capabilities, it is a proven technology to provide the very simple yet effective reporting capabilities. In Text Reporting, the EGL programmer specifies page specification such as width, length, and header/footer rows and what to print and where to print it using very simple function calls. The functions of a Text Report include functions to start a report, output to the report and finish a report. These functions are part of a text reporting engine that has been implemented as a Java external type. The engine provides reporting services to the EGL program. All the report business logic and writing of text is written in EGL. The reporting engine uses callback functions when it determines it is time to print headers, trailers or row data. Call back functions can also be defined to print text before and/or after changes occur in report data fields. These callback functions contain the business logic to print the actual report. For example, the report engine can be told to utilize printHeader() as a callback function to print the page headers. Anytime the report engine needs to print on a new page, it will call the printHeader(). The printHeader function, written in EGL, then utilizes other functions within the report engine to print the actual data to the report. Some additional services of the report engine are the ability to move to a given column, advance a specified number of lines, advance to the next page and conditionally advance to the next page. There is a developerWorks article for EGL programmers interested in more information on text reporting titled “Simple Text Reporting for IBM Rational Business Developer Extension Version 7”. This article provides an overview of the reporting engine as well as sample code for generating reports utilizing Text Reporting. As you are working on migrating I4GL reports to EGL or writing new reports, consider Text Reporting. It is the preferred reporting method for I4GL type reports. It might also be work looking into BIRT for graphical/html reports. Look for up coming articles on BIRT with EGL.

Vincent Petrillo Sr. Software Development Manager, IBM, Le

© Copyright 2007, International Business Machines

nexa Kansas

18

© Copyright 2007, International Business Machines 19

Application Transformation to EGL Introductions

From all points around the world there are companies such as yours that are desperately seeking a way to modernize their legacy applications. The idea of having to replace these applications with an off the shelf product, or rewriting those applications is so costly and time consuming most companies will not even consider these to be alternatives. Because of this, IBM has been teaming with business partners who have developed tools that automate the transformation of legacy applications to EGL. Imagine:

• being able to save all of that very valuable business logic and process you have invested in for years to run your business.

• moving your application to a platform where you can continue to maintain and enhance that very same application in a more modern development environment.

• continuing to use one of your most valuable assets, the business knowledge in your employees brains.

• doing it in a fraction of the time that it would take to replace or rewrite your applications.

EGL is a core component of the comprehensive Application Life Cycle and Management solution from IBM Rational, it is a highly productive, flexible language that offers a development model familiar to your business oriented developers allowing them to quickly build modern business solutions without having to learn and master Java, Web technologies or Service Oriented Architecture, thus eliminating the need to re-staff in order to create the next generation of IT systems. Knowing how crucial your investment in existing legacy systems is, Enterprise Application Transformation tools help migrate your business-critical applications to EGL to fully leverage their business value. Specifically, (refer to the diagram below) through code migrations of VAGen, I4GL, Natural, RPG, COBOL, CA Cool:Gen, CA Cool Enterprise, CA Ideal, CA Synon, Maestro and other 3GL and 4GL applications. These tools can leverage your existing investment in proven, reliable, production-ready code, preserving this logic while moving rapidly onto a modern software development platform. This is made possible through highly automated conversion utilities designed to migrate the specific legacy environment to EGL in a cost-effective, efficient manner, greatly reducing risk while shortening the migration process.

© Copyright 2007, International Business Machines 20

Application Transformation to EGL Introductions - continued For example, we have business partners such as FBD Associates that has a tool that will transform a Natural ADABAS application to EGL and DB2. Another is PKS that will transform COBOL applications to EGL. No matter what tool is used to transform an application to EGL, there is a structured three phased process that is followed. The first phase is the Discovery aNd Analysis (DNA) phase. This is where your application is inventoried, and an audit of the code base and data accesses are performed. This is required so that everyone understands the scope of the project with ‘eyes wide open’. It allows for the removal of dead and/or duplicate code, analyzes coding styles and can identify possible conversion problems. It also provides information that allows the transformation project to be broken down into consumable, achievable subprojects. The second phase has two components that are occurring in parallel: The On-Site component that establishes the new application development and deployment environment (RAD/EGL (RDBe), the new DB environment if applicable (DB2), the new Application Server environment if applicable (WAS), and any other software tools required. There also has to be education and knowledge transfer in EGL/RAD (and WAS & DB2 if applicable). The Off-site component is the actual running of the legacy code through the conversion engine. This is a highly automated process that produces the EGL and typically is very iterative allowing the team to make changes to the engine if needed to accommodate any unique characteristics of the application. It is then rerun through the conversion engine. The objective is to have a resulting 95% transformed application. Why not 100%? Because there is always something the conversion tool does not have the intelligence to determine what to do and thus can not transform. This typically requires someone with the business knowledge of the application to help remediate and complete the transformation. For example, Natural applications have an operation that allows the user to ‘Escape top’ or ‘Escape bottom’. There is no equivalent to this in EGL so typically a routine will need to be written in EGL to mimic this behavior. The Third and last phase of a transformation is about implementation, testing and deployment. This is by far the longest phase and requires the most of yours and the business partner/service provider’s involvement. While the first two phases mostly happen off site, during this period the transformed application is delivered, imported into RAD, generated, deployed, and tested on your system. Now your application is in RAD. We know that the beauty of EGL is in it’s versatility - supporting many styles of programming – Services for SOA, Web, Green-screen, batch and soon Rich Internet Applications (using RCP) – across the broadest variety of platforms - System i, System z (CICS & batch), Linux, Unix, and Windows - EGL provides maximum flexibility for transforming applications. For example, since most online legacy applications provided green-screen interfaces, there is the opportunity during the migration process to provide new Web User Interfaces (UI), as appropriate. Or if the objective is the redeployment of stable application functions for SOA, then application transformation to EGL sets the foundation for this to be accomplished. So, to summarize, EGL (and IBM) can play a critical role in mitigating the risk of your Application Transformation. EGL and its open standard, Eclipse-base software development platform can future-proof your IT application organization from the ever changing world of middleware, databases, languages, platforms and computing environments.

Application Transformation to EGL Introductions - continued By working with the Enterprise EcoSystem Team, IBM Rational Services, and our Business Partners we can transform your application into EGL. This is a very doable alternative. From here you are plugged into the Rational Application Development platform where you can

• Use tools such as Rational Requisite Pro, Rational ClearCase and ClearQuest • Deploy your applications to the platform of your choice • Use Rational Test Suite of tools, i.e. Performance Tester, Functional Tester, etc.

You have essentially opened up your application to a whole new realm of possibilities. So, to summarize, EGL (and IBM) can play a critical role in mitigating the risk of your Application Transformation. EGL and its open standard, Eclipse-base software development platform can future-proof your IT application organization from the ever changing world of middleware, databases, languages, platforms and computing environments.

P. Michael Virga Jr. - Mike is one of the members of the IBM Rational Enterprise EcoSystem Team and has been traveling around the world giving presentations on Application Transformations and EGL. He can be reached at mvirga@us.ibm.com EGL is a platform… not just a programming language.

EGL supports a variety of SOA related capabilities that help business-oriented developers become extremely productive in a short time. Stefano Sergi, Product Line Manager

-

© Copyright 2007, International Business Machines 21

© Copyright 2007, International Business Machines 22

Best Practices – Source Management EGL and ClearCase Integration

Here is a summary of the best practices for EGL and ClearCase integration. They are also applicable to developing applications based upon any of the Rational and WebSphere application development tools. Isolate EGL projects into separate VOBs or folders The basic unit to control the version of EGL assets is the EGL projects, one EGL project can be put into one specific directory under a specific ClearCase VOB, so it’s always a good practice to organize the EGL assets into multiple projects so that the maximum flexibility can be achieved. There are some factors need to be considered synthetically when organizing the EGL project structure:

• Application architecture and/or design patterns

A good project organization which matches the application architecture or some kinds of design patterns will help the EGL development organization shift to component based architecture, product factories and further easy for the SOA application development.

Take EGL web project development as a sample, we can organize the EGL projects based on the MVC design pattern, such as the data and data access parts (consist of data record, data access routines, etc) can be put in one project. The other business logic, page handlers and web representations can be in another project.

• Team roles and security request

If there are different developers working on SQL access vs. business logic for example, then a project structure can be created to isolate these development efforts. To accommodate the above situation, you could create a project to contain the functions and records layouts needed for SQL access and different project for the business functions thereby minimizing the number of developers working on a single project.

In addition, it’s always a good practice to organize the common code into an independent project, give the dedicated team the write permission to maintain it, while other project teams can only refer to it.

ClearCase has two layers to organize the EGL/Rational Application Developer software assets. The top layer is VOB, which is a physical repository to store all the versioned objects, you can put higher level security settings on the VOB, for example only members of one specific department can access this VOB. The lower layer is the directory, one EGL project can be mapped to one directory under a VOB, you can also set the directory permissions in ClearCase, like group A can change anything in this EGL project, group B can only read or reference this project etc.

• Access performance

Including 600 programs in a EGL project or just a program for each project? There will be a kind of trade-off between both to fine tune performance. There are a group of ClearCase service processes for one VOB, so normally it’s recommended not to put too many files (e.g. no more than 10,000) in one VOB.

So for EGL projects, you can consider to organize them into one or multiple VOBs depends on the request of performance, security access etc. In general, putting all the EGL projects in one ClearCase VOB or one EGL project per VOB are poor examples.

Best Practices EGL and ClearCase Integration - continued Only version control “necessary” files Source files are generally versioned and shared with other project team members, while some temporary or target object files during build are typically private and not shared. Users must ensure that the right files are versioned; that is, a user may not want to version and share those temporary or target object files and some build settings, but may wish to version and share source files. Rational Application Developer provides an option (see the Windows->Preferences->Team) for ignoring specific file types that you do not wish to add to source control. The ClearCase integration adds a default list of file types to this list of Ignored Resources.

In terms of EGL code generation, the generated Java or COBOL code is a kind of production code and should NOT be modified, so an interesting decision should be made is whether or not we should add those generated code into source control. The answer is “it depends”.

If the development team is not big, say less than 5 people, and the project itself has a small number of EGL programs so each developer only looks after their own code, then they probably can run a single and sequential release process. In this case it really doesn’t matter to add the generated code into source control or not.

If it’s not the case, you may need to a fine control on this, otherwise you have to deal with both EGL source code and the generated code, for example some conflict happens on the EGL source files which have been modified by different developers, when you merge the changes you’ll have to put some extra effort, actually it doesn’t make any sense to compare and merge the generated code, right? However for the big EGL projects, keep everything (include the EGL source files, the generated code and even the execution code) in remarkable baselines is very practical, it may save some time in code regeneration and recompilation when they’re needed. Again, for EGL projects, especially for the big development team, a detail and fine control is very necessary, you need to consider some key SCM policies and EGL code generation features together. Here is an example:

© Copyright 2007, International Business Machines 23

© Copyright 2007, International Business Machines 24

Best Practices EGL and ClearCase Integration - continued

Development Stage

Integration Stage System Test Stage

Production Stage

Only version the EGL source files, the unit testing can be done with EGL debugger. Deliver the EGL source code to the integration area (e.g. integration stream/branch).

Merge all the EGL source files delivered by the development team, resolve all the conflicts in the EGL source code. Version the build descriptors (.eglbld) and other build and generation related files. Generate the target source code (e.g. COBOL or Java) based on the EGL source code, build the final executables based on the generated code and do the integration test. If the integration test passed, then version the generated code, the final executables and baseline everything if necessary, then deliver the final executables to the system test area (e.g. system test stream/branch).

Do the system test based on the executables delivered from the integration test area. If passed deliver to the production or release area (e.g. release stream/branch).

Release the executables in the final production environment.

Taking an EGL web project as a sample, we may not version the generated java code and some libraries. But for a huge EGL/COBOL project, we may version all the generated COBOL code and even the built load modules since the integration stage so the build effort in the later stages can be avoided. You may find other best practices when you doing other applications or under different situations.

Use a separate Rational Application Developer workspace for each ClearCase view Often, developers work with multiple ClearCase views of the same Application Developer project, and these views must be accessible from the Application Developer workspace It is recommended that you associate one ClearCase view with a unique Application Developer workspace. For example, if you want to work in a parallel-development environment where you have a development View A for bug fixes to release A, and another development View B for release B, you would have two different Rational Application Developer workspaces: one for View A and one for View B. This makes it easier to switch among different versions of the same Rational Application Developer project by simply opening another workspace associated with the necessary Rational ClearCase view.

In summary, no matter what kinds of ClearCase view you’re using, snapshot view, dynamic view or CCRC web view, creating different Rational Application Developer workspace for each view is highly recommended.

Create a standardized development environment It is important that all project team members share a common development environment to ensure consistency and reduce integration problems typically related to inconsistent build settings or other configuration problems. One way to help avoid these problems is by sharing common configuration information with simple projects. Simple projects can be used to store common project artifacts, such as getting-started instructions, build instructions and guidelines for team preference settings. Doing so can save developers time by providing consistent workspace, build settings and other environment settings. Use Team Project Sets to define consistent lineups of Rational Application Developer projects

Team Project Sets specify a list of Rational Application Developer projects that are under version control, which can then be quickly imported all at once. This saves time for developers, because they do not have to import individual projects and they are also free from having to understand project dependencies.

Best Practices EGL and ClearCase Integration - continued

Add third-party libraries to source control To help eliminate dependencies on local build environments, as well as incompatibilities between JAR versions, third-party JAR libraries should be considered to place them under version control. Rational Application Developer projects can then reference these third-party libraries as external JARs. This can also allow team members to have a common class path, because the JAR files are stored in a single, common location under version control.

The synchronization between ClearCase and Rational Application Developer Sometimes you may need to change something in ClearCase outside of the Rational Application Developer IDE. Once you’ve done something outside of Rational Application Developer, it will cause inconsistent between Rational Application Developer and ClearCase. For example testpage.jsp has been checked out in ClearCase Explorer and changed to version 7 via Notepad, but Rational Application Developer still thinks the version is 6. In this case, you need to run Team Refresh Status to sync ClearCase and Rational Application Developer. The context menu item “Refresh” doesn’t help here because it doesn’t reflect the ClearCase status.

In addition, in ClearCase SCM Adapter there is an option “Perform Refresh Status operations recursively”. You can select to recursively refresh all the folders or objects under the selected object.

Ji Hua Li is in IBM Sales & Distribution, Software Sales - lijim@cn.ibm.com He is a SENIOR I/T SPECIALIST - Field Technical Sales Specialist (FTSS) – with emphasis in RATIONAL.SW Configuration Mgmt-CORE

© Copyright 2007, International Business Machines 25