You may be familiar with the use of Java archive (JAR) files in Eclipse development environments. You can include Jar files in the Java Build Path of a project. The Jar files contain compiled Java classes and optional associated Java source code that has been tested and released for use in other Java programs.
Version 22.214.171.124 of Rational Business Developer (RBD) introduces the concept of EGL archive (EGLAR) files to EGL development as a "technical preview." If you are running a large development organization and have shared projects that are tested and reliable, you can now build these projects once, package their EGL parts into an EGLAR file, and import that EGLAR file via an EGL binary (read-only) project into the work spaces of many developers. References to EGL parts in the EGLAR are resolved when the binary project containing the EGLAR is in the EGL Build Path.
To learn more about the capabilities provided in EGL archive files in the technical preview, see the EGL Archive Files section of the wiki. You can reduce the time spent for build and generation by creating EGLARs to package your common code and share it between projects and workspaces. We hope you'll make use of EGLARs in your application development process. Let us know what you think!
In RBD v8.0.1, laying out a Rich UI from the Design view became much easier. When you create a Rich UI handler, you'll get a GridLayout widget by default in the code template. GridLayout is a flexible layout widget that replaces the Box widget that was part of the RUI handler template in RBD v7.5.x. With GridLayout, you can drag and drop widgets from the palette into any cell of the GridLayout. Change your mind on where a widget should go? Just drag and drop the widget to a different empty cell. Easy!
You can define the total number of rows and columns from the Properties view to best suit your needs; the default is 4 rows and 3 columns. As of RBD v126.96.36.199, you can insert a row or column in your GridLayout. The Insert commands come in handy when you are using the Visual Editor and find that you need some additional space in the middle of your RUI.
The cells in the GridLayout automatically resize based on the largest widget within that row or column. You can define alignment and span properties under the Layout tab. Have a widget that should occupy the space of multiple columns? No problem! Just set the horizontalSpan property. Want to left align the widget? Set the horizontalAligment property to LEFT. Alignment and span properties are available for horizontal and vertical orientations. You can also define padding, either by cell or for the entire GridLayout.
Using GridLayout, you can make the most use of Design view and quickly create and modify complex UIs.
Just wanted to follow-up Lisa's announcement of fix pack 188.8.131.52 with a summary of the changes to Rich UI (RUI). Of course, you can find all the details in the Rational Business Developer v8 Information Center.
RUI Editor Enhancements
The Rich UI editor features a handful of usability and productivity
GridLayout was introduced in 8.0.1 as the default layout because of its versatility and the ease with which complex layouts can be created – particularly for forms. This fix pack makes GridLayout even easier to use by adding the ability to add or delete rows or columns within the Visual Editor. Your user interfaces are now much easier to create and maintain as your application evolves.
Deleting widgets within the Visual Editor now does a much better job of cleaning up the source code to reflect the deletion. Deleting a widget from either Design or Outline views removes the widget's declaration as well as generated references to the widget including in layouts, controllers, and formFields. However, any custom code that references the widget will result in compile errors that will need to be cleaned up.
Visually edit custom RUI Widgets using the same Visual Editor you're already using to graphically compose RUIHandlers in your Rich UIs. Your widgets can be realized faster using the Visual Editor, which in turn will help foster reuse to the extent you break your interface up into custom widgets.
RUI Widget Enhancements
Before I mention the improvements to MVC and validation, note that
these changes use new versions of the RUI widget project
(com.ibm.egl.rui_3.0.0) and the Dojo widgets project
(com.ibm.egl.rui.dojo.widgets_1.1.0); these are now the default
packages for new RUI projects.
Text Widget enhancements allow you to specify prompts and and error messages for Dojo widgets with validation support. The Dojo text widgets have been extended significantly; DojoTextArea and DojoTextField join the already existing DateTextBox, TimeTextBox, and CurrencyTextBox.
Validation support means
you can now specify view-level logic for ensuring your users input is
what your application expects. RBD provides a set of validators
covering things such as email addresses, and you can easily implement
At design time, you can specify constraints, validation logic, and associated messages and prompts.
At design time, you can specify constraints, validation logic, and associated messages and prompts.
In the resulting UI, note that the userName field shows an error since it has inputRequired property set to true and there's a prompt message for birthDate.
Custom widgets can now participate in Model-View-Controller (MVC) using the @MVCView annotation. With @MVCView, your custom widgets can serve as a controller view by fulfilling certain responsibilities, which briefly speaking, include getting or setting the widgets contents as text, as well as determining when the widget's contents are valid.
Getting Started with RBD 184.108.40.206
Simply surf over to the Release Information for all the details, including all the other changes in addition to the RUI changes I've highlighted here.
These changes build on all the many RUI enhancements added in RBD Version 8, so you might want to review or even acquaint yourself with Version 8 by checking out the developerWorks article on “What's new in IBM Rational Business Developer Version 8”.
First off, thanks to everyone that came out to the EGL Conference last week in Wiesbaden, Germany. What a great event it was! Stef, the self-titled Czar of the conference, wrote a nice summary, check it out. Here are some of the main things I picked up on and/or observed and/or thought about as I was driving 200 km/h to Frankfurt last Friday night ...
Once you're hooked, there's no going back
For me, it's always energizing to be around people that "get it", and there was no shortage of these people at the event. Although I've said it before, it's worth saying again: once a person tries EGL with an open mind and puts in a little effort, they are hooked and never look back. As programmers/technologists, we should be willing to give anything a try (at least once) - and, by anything, I mean other languages and technologies, of course. I just don't see enough of this today, especially in "established" IT communities. On a related note: I don't know how many times I've heard: "oh, yah, we tried EGL like 3 or 4 years ago and didn't like it". I can almost understand this (to a certain extend), but at the same time: stuff changes and gets better; especially EGL. Just look how far EGL has come in 3 years, and imagine where it'll be in another 3 years! And imagine where EGL will be when I'm gray and balding (many, many years from now) ...
Open, open, open
We officially launched the EGL open project in 2010, and, man, what a journey it has been. EGL was designed for extensibility - i.e. to be able to support new languages, platforms, and frameworks, but this was largely impossible for anyone (but IBM) before. With open, the impossible will soon be possible. The demo Tim did around the Android Java generator perfectly shows the true power of EGL to be the most flexible, extensible, and strategically-smart language the world has ever seen (OK, that may be pushing it ... but maybe not). I can't wait to see all the ways people extend EGL and all the places EGL generated code will soon be running.
As a side note: if there was ever any doubt as to the brain-power behind the EGL technology, those doubts were obliterated as Tim (Wilson) described how EGL is put together and how the open project is going to make it possible to extend our generator, create new generators, or builds tools that make the lives of developers better. Sleep tight at night knowing we have some really bright people working on this stuff.
EGL does that?
I would say the highlight of the day was the brilliant demo by Aaron Allsbrook (from our partner ClearBlade). The demo showed how EGL can be used to quickly develop a powerful web application that accesses data from a third-party service, in this case a service provided by Rational Team Concert for accessing work item data. The demo did a great job of highlighting some of the great enhancements in version 8 - from the wizard that creates EGL records from XML or JSON to the improvements in the visual editor for dragging-and-dropping a record to create a UI form. This demo really shows the versatility of EGL --- what other technology can be used for batch programs on System z, but also for building modern web 2.0 style mashups? Answer: no other technology.
Major thanks to our partner sponsors who invested a lot of time and effort planning the event. Paul, Maurice, Ramona, Eric, Aaron, Jens, Maria, Heidi, Elvin, Stef, and Theresa - thank you all.
Already looking forward to EGL Con 2012 ...
After a few delays, Rational Developer for i for SOA Construction (RDi SOA) version 8.0 is here! Read the full announcement.
(Note: customers that get RDi SOA through AAS will have to wait until April 15 for the code to become available)
For those of you not familiar with RDi SOA, RDi SOA is the EGL development tool for IBM i shops. It includes tools for EGL, RPG, and COBOL development on i. It is made up of the following products:
Fix pack 220.127.116.11 is now available. It contains fixes in many areas of the product, as well as quite a few enhancements. Everyone who is using RBD 8.0.1 should install this fix pack. See Rational Business Developer, Version 18.104.22.168 Release Information for more info, including installation instructions a list of the APARs which have been fixed, and the list of enhancements.
There's a little something for everybody!
In a previous post, I introduced a new EGL library for developing native-looking mobile web applications for iOS (Apple iPad/iPhone) and Android. We now want to describe some of the technical highlights of a sample mobile mortgage app we built to demonstrate the libraries capabilities.
To refresh your memory, here are some screen shots of the resulting app ...
Hopefully after reading this blog post and looking through the code, you'll be ready to start building your own mobile applications with EGL!
Getting the code
Download the sample mobile mortgage app project .zip and then import into your workspace (File > Import > General > Existing Projects into Workspace). Make sure you have already imported the EGL Mobile Web library.
Exploring the code organization
The EGL source code for the application is contained in the EGLSource folder of the com.ibm.egl.samples.mortgage.mobile project:
Some of the noteworthy packages ...
Exploring the user interface code
The real meat of the application is in the "ui" package. As discussed above, this package contains the Rich UI handler (RUIHandler) parts that make up the UI components of the application. A Rich UI handler is a logical UI component, containing both the UI definition (i.e. widgets and layouts) and UI-specific functions (like widget event handler functions). The main handler in (and entry point into) this application is MainMobileHandler.egl.
Right click on ui > MainMobileHandler.egl and select Open With > EGL Rich UI editor to open the handler in the visual editor. You should by in the Design tab of the editor, as shown:
Switch to the Source tab so we can walk through some of the code.
Most of the other code is standard EGL Rich UI code. I encourage you to look through the code and play with the application. If you have a question, don't hesitate to post to the EGL forum.
Happy mobile developing!
Geolocation: Your place in the world
We've all gotten acquainted -- and even dependent on -- satellite-based navigation using GPS (Global Positioning System), and GPS receivers are so commonplace they're often found in modern smartphones, tablets and other devices. Although GPS satellites are remarkable engineering feats, the GPS system succeeds on a relatively simple premise: your real-time geographical coordinates enable a wide array of services and features from navigation to geo-tagging to location-based services.
But GPS isn't the only way to figure out where you are. Whereas GPS involves triangulating your position with respect to satellites in space, it's also possible to do similar triangulation of your position with respect to nearby cell towers. This is how some phones can approximate your position even in the absence of GPS hardware (or service). Similar techniques can approximate your position using your WiFi connection or your IP address -- there are any number of approaches with varying degrees of accuracy and various pros and cons.
Fortunately, none of these technical details are actually relevant to adding location awareness to your Rich Internet Application. HTML5's geolocation support provides a simple API that allows you to obtain the current position or monitor it for updates, without regard to how the position is being determined. It's up to the browser to figure out how to obtain location information given the device's capabilities and come up with the coordinates for use in your application. We've "wrappered" this API with an EGL library, which means that your EGL applications have access to the device's geographical coordinates, subject to the user's permission. Keep in mind that it's ultimately up to the user to grant consent for their location information to be accessed. Of course, how this permission is obtained can vary by browser; it may involve some combination of on-screen prompts and browser configuration options.
The preview includes a sample EGL application that illustrates the use of geolocation in conjunction with mapping.
I should mention that while developing this preview of geolocation support, we did encounter some problems with browsers that should've been able to give us our position and yet failed to do so. As always, you should make sure you understand -- and then test -- your target platforms because results may vary across the various combinations of browsers and operating systems.
Web storage: Client-side data
The purpose of Web storage is simple: to provide Rich Internet Applications with a browser-based, client-side storage mechanism, and to do it in a simple, standardized way.
The WebStorage API is based on a simple model for storing key/value pairs and consists of two variants: Local storage and Session Storage. Local storage provides persistent storage that is maintained even if the browser itself is closed. If you're familiar with HTTP cookies, local storage is similar but differs in two important ways. First, local storage is entirely browser-based and doesn't involve any data being transmitted to the server (whereas cookies are transmitted on every request), and second, local storage offers much more capacity -- typically up to 5 megabytes or more depending on the browser's implementation. Session storage is just like local storage except that its data is associated with a single browser window and its contents are lost as soon as that browser window is closed. With this, session storage is particularly useful for those cases in which a user might have multiple windows open at the same time; each effectively will have its own sandbox in which to store temporary data.
The preview includes a sample application that allows you to simultaneously explore local storage and session storage; with access to both at the same time with the sample's straightforward user interface, you can explore how these variants of Web Storage work and how they differ.
If there's a basic premise behind the power of EGL Rich UI, it's this: technology is a means to an end. HTML5 is a technology that offers RIAs some important new capabilities that begin to eliminate the last of the functional gaps between RIAs and their desktop ancestors. So rather than get lost in the noise about what HTML5 is or isn't, take a look at this preview and start to think about how the HTML5 features offered herein can benefit your applications.
Of course, there's much more to HTML5 than these first two features we're covering now, so look for future updates as we add other ways that HTML5 can enhance your EGL applications.
Ready to get started?
alicec 060000B6VQ Tags:  project source egl rbd import eclipse pif java archive export projects javasource folder 9,513 Views
Starting in Rational Business Developer version 8.0.1, the Project Interchange Format (PIF) import/export wizard has been replaced by existing Eclipse Import and Export wizards. You can use these wizards to export EGL projects to an archive file and import EGL projects from an existing PIF or archive file.
To export an EGL project, use the Export Archive File wizard as follows:
In this example, myProject is exported to d:\temp\myProject.zip.
To import an EGL project into your workspace from an existing PIF or archive file, do the following:
In this example, myProject in d:\temp\myProject.zip is imported into your workspace.
Managing Empty Java Source Folders
EGL projects can contain two types of Java source folders.
Due to an existing Eclipse bug (Bugzilla #278402 - [Import/Export] Export project does not export empty folders), empty folders in a project are not exported. If a Java source folder in an EGL project is empty (i.e. not exported), the following errors will occur when someone imports the project:
These problems occur because a Java source folder in the Java build path doesn't exist in the project. (To check a project's Java build path, right click on the project and select Properties > Java Build Path. Click the Source tab to see the source folders.)
The Eclipse bug is being worked on, but until it is fixed, you can either 1) remove or 2) populate empty source folders on the project's Java build path before exporting an EGL project:
If you remove EGLGen/JavaSource but it is later needed to hold generated Java, RBD will create a new one.
This will cause the folder to be exported, thus preventing errors after import.
After importing a project with errors, you can either 1) remove the missing source folder from the project’s Java build path or 2) create the folder in the project:
If you prefer, you can change your Java preferences to treat Java build path problems as warnings instead of errors. To do this:
If you are writing Rich UI applications, having a robust set of widgets to choose from can speed up your development time. With the release of Rational Business Developer (RBD) version 8.0.1, Dojo widgets are incorporated into the product and officially supported. The palette in the Rich UI visual editor contains a number of Dojo widgets for layout, display and input, and data visualization:
Other Dojo widgets can also be used but didn't seem to make sense to put on the palette, such as Context Menu.
The Dojo projects
With RBD v8.0.1, we provide a Dojo widget project and a choice of Dojo runtime projects. Plus, we provide a Dojo sample that shows each of the widgets in action, as well as a few extras like Map, Dialog, and Portal widgets.
When you create a new EGL Rich UI project, you'll see the option to add EGL Dojo support is pre-selected under Widget Libraries. The Dojo 1.0.0 widget set is based on Dojo toolkit 1.5.
When you click Finish in the new project wizard, the EGL Dojo widget project, the Dojo local runtime project, and the EGL Rich UI widget project are automatically added to your workspace along with your new project.
Using Dojo runtimes
Getting the Dojo sample
The Dojo sample provides a useful way to learn how to use the Dojo widgets. You can get the Dojo sample from the Help system. In the Help Contents, go to Samples > Technology samples > EGL > EGL Dojo widgets. Click "Get the sample" link to import the Dojo sample into your workspace. If you don't already have the Rich UI, Dojo widget, and Dojo runtime projects in your workspace, you can use the links on this help page to import those projects as well. Start by opening EGLSource/dojo.samples/Gallery.egl in the EGL Rich UI editor and trying it out in Preview mode.
New in Dojo 1.5
Dojo toolkit 1.5 contains several widget enhancements and fixes, as well as some performance improvements. For EGL's Dojo support, we added Border Container as a new layout widget, in addition to the variety of widgets that were provided in earlier technical preview versions of EGL Dojo which were based on Dojo 1.4 or earlier. RBD v8.0.1 also added DataGrid as a new non-Dojo widget, but that's for another blog. We will continue to add more widgets over time. Add a comment to this blog to let us know which widgets you would like to see.
One main new feature of Dojo 1.5, is the new Claro theme. The Claro theme has several aims:
So try out Dojo in your next Rich UI application, and when asked "Do you Dojo?", you can answer "Hai!"
We are very pleased to announce the 2011 EGL Conference in Wiesbaden, Germany on April 5 and 6! This year's conference offers a variety of technical sessions, customer experiences, product demonstrations and a comprehensive view of the evolution of EGL technology over the past two years. Whether you are already an EGL user, or you are interested in exploring the power of this emerging programming technology, you will find this event very valuable.
Day 1 (Tuesday, April 5)
Day 2 (Wednesday, April 6) - 1/2 day workshop
For the full details and to register for this free (no charge) event, go to http://eglcon.org/
"Occasionally", users will find a bug in RBD (hah, we're trying to make these occasions more rare!). When the problem is reported to IBM Support, we will often provide a test fix at the Fix Portal. All of these fixes eventually get rolled together in to a fix pack. But in between fix packs, some customers end up having to manage quite a few test fixes across many machines. It can become difficult to know which fixes have been installed on which machines.
The ideal solution for this problem, of course, would be for RBD to never have any more bugs! Until that happy day arrives, though, we have updated the tool we use to create test fixes to write to a log file each time a fix is applied.
During installation of a test fix, we will add data to the EGLFixtest.log file, located in the non-shared\dropins\EGLFixtest RBD directory. The information includes the APAR number, time stamp, and the plugins / files being updated.
This log file is only for test fixes - it is not updated or cleared when you install a fix pack.
We have implemented this feature in test fixes for versions 7.5.x and 8.0.1.
We hope you will find this log useful. Enjoy!
A new step-by-step tutorial (Create a mortgage portal with EGL Rich UI) has been added to the Rational Business Developer (RBD) version 8 Information Center, and will also appear automatically in the RBD help if you have the option to "include remote help" enabled in your preferences (Windows > Preferences > Help > Content). This tutorial was originally written for EGL Community Edition, but has been updated for version 8. It shows the basic steps for creating a rich, multi-tier application with EGL.
This tutorial is great for anyone new to EGL or just wanting to learn how to use some of the new features in version 8!
Here is what the resulting application (that you create) will look like (well, assuming you do everything right) ...
This tutorial demonstrates the following concepts:
Note: this tutorial pre-reqs Rational Business Developer version 8 or Rational Developer for z with EGL version 8. Both are available as a 60-day trial.
It's never easy to predict the future of technology, but one thing is clear: mobile computing is the next big demand that IT must respond to, and it will be driven by small form-factor devices. Smart phones and tablets will accelerate the trend begun by laptops and net books towards computing that can go anywhere and do just about anything given their modern hardware and support for browser-based web applications. Many businesses see the value in mobile computing, specifically for its ability to deliver applications and services to its users, regardless of where those users are located. However, a major challenge facing IT and application development teams is building applications that support the many different mobile platforms in use today, specifically Apple iOS and Android. Developing applications for these platforms requires different and specialized skills and tools. This forces development shops to either:
An alternative (and more open) approach is to take advantage of the rich capabilities in mobile web browsers. The web is the common denominator across all modern mobile platforms, and improvements in capabilities and adoption of standards like HTML 5 make modern mobile web browsers quite capable as a platform for mobile applications.
In late December, we delivered a sample library for developing mobile applications with EGL. This library provides EGL developers with widgets for developing mobile web applications that take on the look and feel of a native iOS or Android application. Some of the benefits of this approach:
Want to see an EGL Mobile Web application in action? Access the following URL from your mobile web browser (or desktop web browser): http://www.myegl.org/MobileMortgage/
The application demonstrates the basics of the EGL Mobile Web technology. It also demonstrates:
With this technology, developers are able to quickly build mobile web applications that look like native mobile applications. Here are screen shots from the application linked to above (same application, but different look and feel depending on the device):
Ready to get started?
To view the documentation or download the library (Rational Business Developer version 8.0.1 or higher, required) - visit the EGL Mobile Web Preview page on the Cafe.
Welcome to 2011!
Hi there EGL Hard-chargers and all others new to EGL. We have a new version of RBD (v8.0.1) and with it, a new version of the EGL Distance Learning Class!
We have just announced the Distance Learning Class dates for 2011 (with the first class coming up January 24 - 28th! - Yikes!), for more information and the link to register for the class, click on the link below:
EGL Learning Center
FYI, the new version of the course will be using RBD (v8.0.1) instead of EGL Community Edition. This will allow me to show you via workshops the new features
of RBD v8 and additional capabilities of our EGL tools such as the Data Access Application wizard, Deployment to WebSphere Application Server (note however that for the class we will still primarily use Apache Tomcat...), etc.
Take care and I hope to see you online soon!
P. Michael Virga
IBM Rational Application Transformations Team,
IBM Software Group
Check out the new What's new in Rational Business Developer 8 article on developerWorks! This article describes many of the new [great] features in version 8 ...
The new version of Rational Business Developer is now generally available! As I explained in October, version 8.0.1 represents a major update, and has some very compelling new features, especially for those of you developing Web applications and services.
How to get version 8 ...
Either method works regardless of whether you have entitlement to the product or not (alternatively, you can download the RBD 8.0.1 parts from the PPA site). Once you install the trial, you can apply the version 8.0.1 license activation kit (or configure your floating keys). As always, post any questions to the EGL Forum.
Let me be the first to thank the great team of architects, developers, testers, and writers (spanning multiple continents) that put in long days (and nights) to deliver this new release!
Looking forward to your feedback (both good and bad) ...
In case you missed it, Rational Business Developer (RBD) version 8 was announced today! Version 8 represents a major update to RBD. The release is built on a new level of Eclipse (3.6) and includes a great set of new capabilities, many of which are focused on improving developer productivity and ease of use. Lots of focus has been put on improving our core UI technology (Rich UI) including major improvements to the visual editor and a new, richer set of widgets. New capabilities have also been added to the debug and test facility (including conditional breakpoints) and to generation and deployment.
Stay tuned as we roll out more details about the planned capabilities. All of this leads up to the planned availability on December 3, 2010.
It's been awhile since I gave an update on the EGL open source project. As many of you know, at the Rational conference in June, IBM and 7 partners announced plans to create an open source project for the EGL language, compilers, and subset of tools and generators on Eclipse (read the proposal). For many of you that have been around EGL for awhile, you know this is a big thing. Besides getting more people involved in driving innovation around EGL, making EGL open will drive new people to the technology. As many of you know, there is a big group of developers and shops out there that won't even consider a "non open" language. There are many different forms of "open", but we view open as making the source of the core EGL technology available to everyone, under a truly open license. Contributing a good portion of EGL (including the language itself and compiler) to Eclipse does just this.
I was recently ask by Chris Maxcer "why is making EGL open source cool"? I think my response captures what many of us in IBM believe ..
Making EGL to open source is cool because it's going to really broaden the awareness of the technology and open EGL to a whole new group of developers. This includes expanding beyond the traditional IBM customer base. Also, for a long time we have been hearing that although EGL seems like a great technology (it is, btw), there has been an unwillingness to take on the risk of a proprietary language. I certainly understand the concern: there have been plenty of examples in the past where vendors have either discontinued the technology or jacked up prices on their customers. There is also inherit risk in any single-vendor technology, since nothing says the vendor will be around forever and that their commitment to the technology will remain the same. Open source allows a technology to grow and evolve outside the boundaries of a single company. In most cases, this results in a better, more well-rounded technology that better addresses the needs of *all* its consumers.Anyway, back to the original topic :) On Wednesday, August 18 we submitted the required project creation documentation to Eclipse. Eclipse has a well-established process for reviewing and accepting new projects, and just like every other Eclipse project, we are following the same process. Barring any major setbacks or objections, the Eclipse EGL Development Tools project should get approved for creation on August 25. Feel free to crack open a cool beverage and celebrate when this happens, I know I will ...
The next big step is for us (IBM) to begin seeding code into the project. As you can imagine, we have a lot of code that needs to be refactored and made open source ready. This work has already started, and you should start seeing code out in the Eclipse project in the next few months.
Let us know what you think ...
Within the EGL Dojo widgets you can expect numerous bug fixes, 7 new widgets and a new Dojo specific event that notifies you when a specific Dojo widget has finished rendering. The new widgets are the: