![Close [x]](http://dw1.s81c.com/i/c.gif){kind=small}
Learn about new features now available in the new IBM Rational® Business Developer Version 8.0.1 solution. Featuring a large number of new and enhanced features, this article provides an overview of the changes, with details as to how these capabilities can help you improve your workflow and productivity.
Note that this article is about Rational Business Developer Version 8.0.1; for simplicity we will refer to it simply as Business Developer Version 8.
What is Rational Business Developer?
Before we explore the highlights of the new release, let's review Rational Business Developer. For a more detailed introduction to Business Developer, please see the Business Developer 8.0 product announcement letter.
The Rational Business Developer solution's purpose is to meet the unique challenges of developing modern business applications. These applications often span a complex mix of platforms, protocols, and architectures. In some cases, a company also needs to respond to the added complexity of a merger or acquisition.
This complexity in modern software forces developers to specialize, and the differences in background and skills can be large — especially in a merged company. As a result, developers that need to develop business applications often have very different backgrounds and skills.
Compounding all of this is the industry's rapid shift to Web 2.0 Rich Internet Applications, where browser-based applications now have the potential to be just as capable as traditional desktop applications. However, developing business applications for Web 2.0 demands staff and skills that may not be readily available.
The Business Developer tool meets these challenges with several unique design points. It provides developers of diverse backgrounds and skills with an Eclipse-based workbench for a modern programming language called Enterprise Generation Language (EGL). Derived from decades of experience with high-level programming languages, EGL incorporates the best features of proven languages such as Java and COBOL to simplify development and provide a single language for end-to-end development of the business application. Instead of trying to keep up with technology, business developers code their business function in EGL, which is then translated to the appropriate runtime technology. In effect, developers are shielded from middleware and runtime complexities.
Figure 1 gives you a sense of what the Business Developer environment looks like, illustrating its Eclipse-based interface and the use of Rational Business Developer's Visual Editor to create a Rich Internet Application.
Figure 1. Visually construct modern business applications with the Business Developer solution
In fact, by using Business Developer as their development environment for EGL, developers can build a wide range of applications and infrastructure, including:
- Business services can be created or accessed in EGL, allowing applications to leverage service-oriented architectures without getting mired in the technical details.
- Web 2.0-style applications written in EGL allow you to deliver these modern solutions without needing to learn the underlying technologies (JavaScript, Ajax, and HTML). The entire end-to-end application can be written in EGL, often implementing the back end as EGL services and the front end using the Business Developer tool's Visual Editor to graphically compose a Rich UI.
- Traditional Web 1.0-style applications are possible using EGL's underlying support for the proven Java Server Faces (JSF) framework. Your application logic is written in EGL, allowing you to benefit from JSF without having to learn its intricacies.
- Portlets are possible by deploying web components developed in EGL to the WebSphere Portal solution.
- Reports are possible using EGL's integration with Business Intelligence and Reporting Tools (BIRT), an Eclipse-based open source reporting engine.
- Batch systems may be written in EGL, which has language support for writing batch programs.
- Text UIs for traditional character-based applications (i.e., "green screen", 5250, and 3270) may be written in EGL or migrated from existing systems to leverage the modern development environment provided by the Business Developer environment.
While the Business Developer solution empowers individual developers, project managers will appreciate its ability to be used in conjunction with IBM Rational Team Concert to choreograph teams of developers building business applications.
The Rational Business Developer tool is built on the Eclipse open source platform, which provides a common developer experience for many kinds of development. Because of Business Developer tool's strong ties with Eclipse, in June 2010, IBM and a group of vendors announced plans to open source the EGL technology on Eclipse under the EGL Development Tools (EDT) project. This project will enable a broader ecosystem of developers, vendors, and partners to enhance and extend the EGL technology. The contribution by IBM represents a significant investment and will include the EGL compiler, the Java and JavaScript generation technologies, and a base set of tools. With this contribution, others will have the ability to extend the EGL technology and support new deployment and runtime platforms. The project will also enable the creation of new tools, which will enhance the experience and productivity of EGL developers.
For more information, visit the EDT project page.
What's new in Rational Business Developer Version 8
Included in the new release are significant enhancements geared toward improving productivity and usability, while producing better applications. These new capabilites include:
- Building better user interfaces with improved layout, styling, using a broader selection of business-oriented widgets from the open source Dojo Toolkit.
- Improved usability and productivity for developing Web 2.0 User Interfaces (UI) with the Rich UI Visual Editor. Overall, the Visual Editor tool is now more responsive and memory efficient and a new wizard creates UI data entry forms and data grids from existing records.
- Simplified integration of RESTful Web Services, using new tools that create EGL records from existing XML or JSON schemas and support for calling XML web services with automatic serialization of EGL records to XML.
- Improved code generation and deployment. An EGL project may now contain parts being generated to different runtime targets (e.g., Java and JavaScript), and code generation can now occur automatically as parts are saved. Also, the panel for configuring the build descriptor for a project, package, or part has been improved to make it easier to see what build descriptor will be applied for different targets.
- Enhanced services development for Rich UI now that EGL services can be tested in Rich UI applications without first deploying those services to an application server.
More significantly, however, is the ability to use EGL services to implement server-side logic for your Rich UI applications by using the concept of "dedicated services". These are like any other EGL service except that a dedicated service is automatically deployed and configured with the Rich UI application. - Improved debugging and testing with support for watch expressions, global and conditional breakpoints, and program suspension at various entry points. Also, Text UIs can be suspended at EGL CONVERSE statements, making it easier to debug Text UI programs. Additionally, you are automatically prompted for database and remote system credentials as needed during program debugging, giving you a chance to avoid locked accounts.
- Other enhancements, including support for text reporting added to EGL-generated COBOL applications.
Building better user interfaces with Rich UI
Everyone experiences modern user interfaces every day in platforms ranging from smart phones, desktop operating systems, the web, and even your television. Although these are diverse platforms, the common trend across user interfaces is an emphasis on user interface design and visual aesthetics.
Business applications are now part of that same trend towards better looking UIs, which is why the Business Developer solution offers strong design points for user interface development: the Visual Editor for graphically composing the interface using drag and drop, and the EGL Source Editor for implementing your user interface logic.
The new version builds on these two design points with improvements aimed at producing better user interfaces, including a new more robust layout, support for a new Dojo Toolkit theme, and extensive improvements to the widgets available.
Form and function with GridLayout
Just as real estate is all about location, user interfaces are all about layout — and grids are a proven layout mechanism for more complex presentations such as forms. The Business Developer solution introduces GridLayout as a way of precisely controlling the placement and relative layout of widgets in terms of columns and rows.
Figure 2. New GridLayout supports more robust layouts
Using the Business Developer tool's Visual Editor, you simply drag a GridLayout from the widget palette and drop it on the user interface you are creating. You can then drag other widgets from the palette and drop them on the GridLayout; as you do so, the Visual Editor will display the borders of the GridLayout cells so you can place the widget precisely as desired on the grid.
The versatility of the GridLayout is apparent once you've placed your widgets on the GridLayout. From that point, you can adjust widgets so that they span multiple rows and columns, distributing space within your UI as appropriate for your design.
More business widgets and the Dojo Toolkit
The open source Dojo Toolkit is known for building modern, Web 2.0-style Rich Internet Applications. This JavaScript library provides a robust widget framework that forms the foundation of a new set of Dojo-based widgets in Business Developer for use in building Rich UIs.
As a result, Business Developer Version 8 adds a number of new widgets for presentation as well as layout, including date/time pickers, graphs, currency, and other input widgets (with built-in validation), tab and accordion containers, tree views, and more. These widgets, as well as the Dojo Toolkit on which they are built, are part of the Business Developer Version 8 toolset. You can find them in the Visual Editor's widget palette.
Figure 3. Using the provided Dojo widgets, Rich UIs can now include calendar widgets, tab folders, and more
Better tables with the improved DataGrid
You can tell a lot about a user interface by the way it presents tabular information, and now your tables can benefit from many of the features found in the new DataGrid widget. These new features support sorting, formatting, editing and more.
Figure 4. New DataGrid for tables supporting sorting, formatting, and editing
In the example table above, you can see some of the more obvious features now available for your tables. The optional checkbox column on the left provides a Web 1.0-style selection model for your rows; you can choose whether this column is present. You may also choose whether the table allows selection of a single row, multiple rows, or none at all.
Note also that the rows are sorted. You can programmatically specify which column to sort on and your users can also do the same by clicking on the column header. You can also provide your own sorting algorithm.
A key design point for employing tables effectively is to balance the size of the table versus the amount of data it must show. Usually this means some mix of client and/or server-side paging, both of which are now available to you. You can choose whether to use traditional scrolling or the pagination controls, as shown in Figure 4. With pagination, you can also optionally employ dynamic data loading for server-side paging of your data.
Column formatters are also supported, as you can see from the red values in the example in Figure 4. You can implement column formatters by writing an EGL function that, when rendered, will affect the styling or contents of the cell.
Cell editors are also possible by specifying a function that is called by the DataGrid and which gives you a chance to replace the text of the cell with a widget.
Styling with the Claro theme
Created by a team of visual designers and contributed to the Dojo toolkit, Claro provides a clean, understated theme for your user interfaces. Claro's beauty is more than skin deep: its stylesheets are structured to facilitate changes to the styling as well as to make it easier to apply themes to custom widgets.
Figure 5. New Claro theme looks better, and is easier to change
Because of its design, Claro is now the default theme for Rich UI applications (replacing Tundra). You can choose the theme for your application, and there are a couple of ways you can do this. Assuming you've imported the stylesheets associated with your theme, you can specify the theme in the settings block for your RUIHandler or you can use a new API (RUILib.setTheme).
Improved usability and productivity for developing Web 2.0 UIs
One driving goal of the Version 8 tool was improving the overall Business Developer solution user experience for developing Rich UIs. Performance and responsiveness are improved in several key areas, yet the most significant change directly addresses your productivity. A new wizard creates data entry forms and tables from existing EGL record definitions, eliminating the potential mistakes and time-consuming nature of doing this common UI development task manually.
Turn EGL records into forms and tables
One of the most tedious — and error-prone — activities in UI development is the process of turning data structures into their corresponding visualizations. The new Business Developer solution tackles this scenario by providing a new, simple wizard for deriving form or table UIs from EGL records.
This wizard is accessible from a new view, EGL Data, within the Visual Editor. This EGL Data view displays variable references to EGL records, data items, and primitives. Creating a form or table begins by dragging a variable from this EGL Data view and dropping it onto the Design view of your UI where you want the content to appear. The Business Developer tool then displays the wizard, as shown in Figure 6.
Figure 6. Create forms or tables from EGL records with a simple wizard
Whether the wizard creates a form or a table depends on the type of data you dropped onto the canvas; arrays will result in tables. As seen in Figure 6, this wizard is simple and concise, allowing considerable latitude in the results. At the highest level, you can choose whether the resulting UI is read-only, editable, or a mix of both. For each field, you can choose whether it should be shown in the UI and if so, you can adjust the label, the variable name, and even override the widget type used for presentation of that field's data.
As a result of this new wizard, creating forms and tables from EGL records is almost effortless, especially since it is based on the idea that much of an application's UI is backed by EGL records returned by services.
Usability changes to the Rich UI development
Perhaps the most obvious change in the Visual Editor for Rich UI development is the reorganized palette, which now categorizes widgets according to their function.
Figure 7. Find widgets faster in the reorganized widget palette
This reorganized palette complements another updated feature that enables the Visual Editor to provide better feedback as you're dragging widgets from the palette onto your canvas. Now it is more obvious exactly where the widget you're dragging will be placed in the layout, and in the widget hierarchy.
Finally, while working with the Visual Editor in Version 8, you'll appreciate that it more intelligently responds to your changes with smarter, more efficient updates.
Faster access to widget properties
Visual editors like the one in the Business Developer solution must make it very easy to modify widgets, and Version 8 improves this important usability point with two small but significant changes. The widget Properties view is now available just below the Visual Editor, and the properties are now grouped into separate tabs. By making better use of horizontal real estate, the revised Properties view makes it much easier to see and access more properties on a widget than before. Also, since the Properties view stays on whichever tab you're on, it's now simpler and more efficient to edit similar properties for multiple widgets.
Figure 8. Widget properties are easier, simpler to change
Faster rendering in Design and Preview modes
The Business Developer solution uses an embedded web browser to handle rendering while working in the Visual Editor to graphically compose your user interface. In Version 8, the Business Developer environment now uses a Mozilla-based browser for this rendering so that both Design and Preview modes now perform significantly better and with better memory management.
Figure 9. Visual Editor now renders more efficiently with Mozilla XULRunner.
As shown in Figure 9, you can choose which browser engine is used for design and preview by clicking on "Configure Preferences" in the Visual Editor's toolbar (note that in Preview mode you can still open your user interface in an external browser).
Simplified integration of RESTful Web Services
The heart of any application is the data it manages, and for EGL applications, that data typically takes the form of EGL records. These records abstract the data representation in the underlying infrastructure so that all facets of the application can work with the same representation of the data. This is particularly important for EGL applications that have UIs, because EGL records allow the front end and the back end to work with the same representation of the data.
Version 8 has new support for deriving EGL record definitions from existing JSON and XML schemas, simplifying the task of wrappering an existing service. Also, Business Developer Version 8 adds support for automatically serializing EGL records to and from XML for use in calling services deployed to Java environments.
Create EGL records from JSON or XML schemas
The Business Developer tool's wizard for creating an EGL record has been enhanced to allow you to automatically populate the record's definition based on the structure of some sample XML or JSON, or based on an XML schema. In each of these cases, you can derive record definitions from a URL, a file, or a string.
Figure 10. Create EGL records from JSON or XML schemas
In this example, we'll work with a publicly available XML schema, so we choose "Create from a URL" and specify the web address of the XML schema.
Figure 11. Creating EGL records from a public XML schema
Clicking on "Next" in the "Records from XML Schemas" wizard, the Summary page previews the EGL record(s) that were derived from the schema. In this case, the fairly complex example schema resulted in a number of EGL record definitions.
Figure 12. Preview of EGL records derived from XML schema
This wizard for deriving EGL record definitions complements another new feature covered earlier in this article: the ability to create tables and forms from EGL records. Combined, these two features help enhance productivity, especially if you have an existing service that provides the data you need for your user interface.
XML support in generated Java
The Business Developer Version 8 toolset adds two features to better support XML with EGL targeting Java environments. You can now invoke XML-based web services in Java from EGL using XML (as well as JSON). In addition, XML serialization is now available to EGL services deployed to Java environments using XMLLib.
Improved generation and deployment
As a modern high-level programming language, EGL simplifies development by shielding developers from the complexities of lower-level languages while simultaneously leveraging those languages when building the application.
You can write your entire application in EGL — the front end as well as back end, and when your application is built EGL, it will generate the equivalent code in whatever language is appropriate, whether it is COBOL, Java, or JavaScript (support for other languages in the future is possible using the EGL open source project on Eclipse, as mentioned earlier in this article).
This generation process has several new enhancements this release, all aimed at increasing developer productivity.
From EGL to multiple runtime languages
Previously, a given EGL project could only target a single runtime language – everything in the project had to be generated to JavaScript, Java, or COBOL. Now, a given project can contain parts generated to different languages as appropriate to the part's role in the application. For example, parts associated with a Rich UI would be generated to JavaScript, whereas parts associated with a backend service might be generated to Java or COBOL.
With this change, the target language can be set (or overridden) for each EGL part. In fact, you can specify multiple target languages for a given part.
Improved web services development
Services have become the backbone of modern application development, supporting a variety of infrastructures, protocols, and technologies. As such, they are an important part of application development in EGL. Version 8 enhances Business Developer tool's support for building and integrating services by making it easier to test certain kinds of services that supply data for Rich UIs.
Rich UIs and dedicated services
In the new version of the Business Developer solution, there is a new service concept called a "dedicated service". This service is essentially an extension of your Rich UI, and is deployed and configured automatically with your application. You can think of a dedicated service as something that implements server-side logic for your Rich UI. To create one of these, you simply create an EGL service as usual and use the "@DedicatedService" annotation when declaring variables for that service.
These dedicated services can be tested in the Preview pane in conjunction with your Rich UI. If the source of the service is in your workspace, you can run the service from the Preview pane without it being deployed. Also, if you debug the RUIHandler associated with the Rich UI, the dedicated service will be interpreted and breakpoints in the service will be honored.
Improved debugging and testing
Often when trying to debug a program, you have some idea where and under what circumstances a given problem manifests itself. This is why conditional breakpoints are so useful: you can simply create the breakpoint and specify the conditions under which the breakpoint should stop the program's execution in the debugger. Once the conditional breakpoint suspends execution, you can then inspect variables and their values as well as step through the program execution from that point to precisely diagnose the problem.
In the new version of the Business Developer tool, you can now set conditional breakpoints at both the line and global level. Also, you can now suspend EGL programs at various entry points. When developing Text UIs, you can also suspend EGL CONVERSE statements to understand the flow of the program as well as to examine all of the variables used by the program.
More workflow improvements are available for debugging and testing. You can create watch expressions, which allow you to choose specific variables to watch and inspect — versus having to find a variable within the variables view tree. In addition, you can create watch expressions to view the result of a calculation without having to change the code to see the result.
The Business Developer Version 8 solution also automatically prompts for both database and remote system login if credentials are not supplied or are invalid, helping to avoid locked accounts during development.
Conditional breakpoints with EGL
Conditional breakpoints are now supported for EGL, and they can be specified on a line within your EGL source or they can be specified as global breakpoints that halt your program whenever the condition is true. The conditions for these breakpoints are specified as a logical expression written in EGL and may reference variables that are in scope at that point in your program's execution.
Conditional breakpoints in EGL are very easy to use, and will be familiar to Eclipse users. Simply edit the properties of a breakpoint on a line and you can toggle whether this is a conditional breakpoint and specify the conditional expression.
Global breakpoints are very similar, except that instead of setting them on a specific line in the source editor or debugger, you use the debugger's toolbar to create a new global breakpoint and specify your conditional expression.
Figure 13. Conditional breakpoints can be set on a line or globally
Note that the debugger's Breakpoints tab lists all of your breakpoints, and can also be used to toggle which breakpoints are active.
Figure 14. Conditional breakpoints are identified as such in the debugger
Suspending programs on entry
Another important debugging technique that has been updated for EGL applications is the ability to suspend a program at various entry points.
Figure 15. EGL programs can now be suspended at several entry points
Automatic login prompting during development
The Business Developer Version 8 toolset also addresses a problematic scenario in which applications that access databases or remote systems often inadvertently result in locked credentials, due to repeated log-in failures.
During development, these credentials often get locked due to repeated log-in failures, so the Business Developer environment will automatically prompt for login if credentials are not supplied or are invalid, and it will prompt up to three times. This gives the developer a chance to correct the credentials before the corresponding account is locked out.
In addition to the features and capabilities mentioned above, the more noteworthy of the new enhancements to the Business Developer toolset are mentioned below.
Text reporting in EGL generated COBOL applications
Text reporting is a simple text file report engine that allows the developer to create EGL logic to be used and driven by certain events (e.g. end of page, column change, etc) in the lifecycle of building a report. Previously this capability existed only in EGL Java Generated applications. In the Business Developer Version 8 solution, this capability has been extended to include support for an EGL-generated COBOL application.
Remote VSAM Support for z/OS using TCPIP from the EGL debugger
Many customers who are deploying applications as COBOL to IBM z/OS® need access to VSAM file data. When debugging these applications in the Business Developer environment, the developer also needs access to these files to do their unit test. Previously, this support was only available using SNA protocols (LU62 or TCP62). In Version 8, the Business Developer solution supports access to these files through TCPIP. In addition, the files can be accessed through CICS as CICS controlled VSAM files or directly as native VSAM files.
For information about pre-requisites and operating environments, please see the Rational Business Developer: System Requirements page.
The extensive list of enhancements found in the IBM Rational® Business Developer Version 8.0.1 solution are engineered to benefit business developers, project managers and enterprise architects. Powerful new capabilities help you build better Web 2.0 user interfaces for your business applications, with enhanced usability from improved layouts and new widgets based on the open source Dojo toolkit. Now you can build UI forms and tables automatically from EGL records, and those EGL records may be derived from XML, JSON, and JSON schemas. Lastly, application quality improvements are possible using improved EGL generation and debugging, with support for conditional breakpoints.
Learn
- Find out more about Rational Business Developer
- Browse the EGL Café for links to technical articles and many related resources.
- Explore the Rational Business Developer information center.
- Visit the Rational software area on developerWorks for technical resources and best practices for Rational Software Delivery Platform products.
- Stay current with developerWorks technical events and webcasts focused on a variety of IBM products and IT industry topics.
- Attend a free developerWorks Live! briefing to get up-to-speed quickly on IBM products and tools, as well as IT industry trends.
- Follow developerWorks on Twitter.
- Watch developerWorks on-demand demos, ranging from product installation and setup demos for beginners to advanced functionality for experienced developers.
- Attend one of our no-cost, instructor-led EGL Distance Learning courses.
Get products and technologies
- Get the free trial download for Rational Business Developer.
- Evaluate IBM software in the way that suits you best: Download it for a trial, try it online, use it in a cloud environment, or spend a few hours in the Enterprise Modernization Sandbox for System z learning how to implement service-oriented architecture efficiently.
Discuss
- Join the Rational Business Developer forum to ask questions and participate in discussions.
- Get involved in the My developerWorks community. Connect with other developerWorks users while exploring the developer-driven blogs, forums, groups such as the Rational Café, and wikis.
- Join in the discussion on the EGL Café where topics include RBD, Rich UI, and EGL
Scott Greer works for IBM Rational as a UI designer / developer in Enterprise Modernization, where he focuses on UI architecture for Rational Business Developer and Rich UI applications. Greer recently joined Rational from Tivoli, where he specialized in user experience and systems management.
