Software Configuration Management (SCM) is an aspect of application development that touches on a wide variety of activities. SCM solutions can include tools for manually or automatically dealing with some or all of the following development project aspects: version control, application builds and deployment, quality assurance, workflow and process control, auditing and reporting, and managing software requirements, incident reports, and change requests. (For a more complete listing of all products that handle SCM functions on the System i, see "Software Configuration Management Tools Product Roundup" in the March 2007 i5 Route Finder on SystemiNetwork.com.)
However, not all SCM products interface with WebSphere Development Studio client (WDSc), IBM’s integrated development environment (IDE) solution. Of those that do, we asked seven vendors of representative products to provide a summary of how their products fit into the application development process, what plug-ins their product has for WDSc, benefits those plug-ins offer WDSc users, and any tips they might have for using their plug-ins with WDSc. Each description is followed by the vendor or product URL at which you can gain additional information about each offering. Although not all vendors provided answers in every area, a summary of their responses appears below.
Aldon Lifecycle Manager (Figure 1) is a process-driven software change and configuration management solution that provides automated and streamlined management of development processes to increase productivity, improve code quality and meet regulatory requirements. Aldon Lifecycle Manager plug-ins bring enterprise software configuration and change management to the WDSc and WDSc Lite development environments. Based on Eclipse 3.0, the Aldon plug-ins provide sophisticated SCM from within the WDSc interfaces, freeing developers to focus on software engineering, not change management.
Aldon’s process-driven SCM plug-in delivers the necessary infrastructure for developers to engage in seamless application integration offered by WebSphere while supporting migration of application modernization. With it, developers have a single point of observation and control that enables them to implement consistent processes across the enterprise and provides management with the information it needs to meet its quality and delivery objectives. The Aldon solution also provides a central repository for the ideas, designs, discussions, requirements, tasks, and other information that team members must be able to access readily. Development processes and tasks can be automated and effectively managed through its integrated workflow capabilities, freeing up developers’ time to concentrate on building applications rather than fulfilling administrative functions. In the complex WebSphere environment, an SCM system serves as the plumbing that lets IT consistently deliver high-quality applications that meet end-user requirements on time and within budget.
Key functions of the Aldon Lifecycle Manager plug-ins include:
- WDSc support lets developers access process-driven application-lifecycle management tools from within the WDSc interface
- Automation and enforcement of IT business processes across the application lifecycle
- Multiple-release management ensures the quality level of software
- Role-based security maintains project integrity from application development through production
- Automated distribution and deployment increases productivity throughout the development lifecycle
- Streamlining of regulatory requirements and best-practices enforcement
- Full multitier inventory management of applications, services, source code, software development artifacts, metadata, configurations and components
- Role-based interfaces for engineers, project leads, development managers and senior IT management
Aldon was the first SCM vendor to offer full integration with WDSc Lite. IT departments gain all the benefits of SCM for the lightweight IDE, creating an efficient and comprehensive environment to attract RPG developers.
Daniel Magid, CEO of Aldon, foresees solid demand for the Lite IDE and the new plug-in. "The WDSc Lite is fast, easy to manage, and takes up fewer system resources than the full WebSphere workbench," he says. "It certainly represents an enticing, easy to install option for System i programmers, which is why it was so important for Aldon to deliver this plug-in. We’re seeing great demand from current customers and prospects."
Because Aldon uses WebSphere’s "team repository" approach rather than the proprietary, "perspective" approach of some other vendors, WebSphere Studio developers and project managers can operate on objects for i5/OST, OS/400T, Linux, OpenVMST, Unix, Microsoft Windows, and z/OS from within a single repository using standard team-repository right-click menus. Developers can develop, test, and manage even complex, multitier, cross platform projects, including Web services or SOA applications, within WDSc interfaces.
With the Aldon plug-ins, developers can take direct advantage of the WebSphere Studio environment as architected by IBM, dramatically reducing the learning curve for executing change management. No additional training is necessary to understand the user interface, views, or functionality. Developers use the development environment with which they are the most familiar, because the Aldon plug-ins support:
- Native source comparison
- Team synchronization view
- Any resource view such as Remote Systems Explorer or Java Package Explorer
- Any IDE perspective such as Java or C++.
Continuously running in the background and separate from the developer’s desktop, Aldon Lifecycle Manager provides management of software development processes. Aldon Lifecycle Manager handles the complex operations of code sharing, security, versioning, and promotion throughout the development-lifecycle process. Aldon Lifecycle Manager manages all the inventory of a project and enables development managers to easily track and approve the flow of software assets from development through stages of defined testing and into production.
For speed and simplicity, the Aldon plug-ins for WDSc, and WDSc Lite initiate automatic checkouts of code from a workspace resource tree whenever the code is edited. By simply selecting and clicking an action from a context menu, developers can manually check out code to their WDSc workspace. Aldon Lifecycle Manager also coordinates and synchronizes files across related releases, eliminating the error-prone manual steps typically required for multiple-release coordination.
From a simple WDSc or WDSc Lite context menu, developers can instantly select Aldon Lifecycle Manager’s change management actions to accomplish the following actions:
- Add: Registers the developed software asset in the repository
- Check In: Checks the asset into the repository for safe-keeping
- Check Out: Checks the asset out of the repository into the RAD or WDSc Workspace for modification. (Assets are automatically checked out from the repository when a developer edits it in the RAD or WDSc editor.)
- Cancel: Reverses a prior Check Out
- Get Latest: Searches throughout the project team files for the most recent version of an asset and copies it into the developer’s RAD or WDSc Workspace
- Synchronize: Compares and merges an asset in the RAD or WDSc Workspace with a repository version.
WDSc is a powerful IDE that can improve programmer productivity, but it alone cannot ensure trouble-free software development and deployment. For that, you must also integrate Application Lifecycle Management principles to coordinate and control all program development and maintenance. That’s the job of ARCAD-Skipper from ARCAD Software, Inc.
A true application lifecycle management solution such as ARCAD-Skipper (Figure 2) incorporates conventional change-management features but goes well beyond that. In addition to traditional functions, such as program check-out and version control, it provides a comprehensive change-impact analysis feature that can eliminate problems that IT might otherwise overlook. The impact analysis parses all application code to find and catalogue program interactions and dependencies. Developers can review these cross-references before working on a program so they know to analyze, modify if necessary, and test those other programs as well.
A key ARCAD-Skipper advantage is that it works in heterogeneous environments, including i5/OS, OS/400, Linux Unix, and Windows. Its impact analysis and other functions work equally well with most major programming languages. So if an organization uses, for example, Java alongside RPG or Cobol, ARCAD-Skipper can still recognize and inform developers of any cross-references between programs. This makes ARCAD-Skipper an invaluable foundation for modernizing your application portfolio and it facilitates introducting new technologies and platforms into your existing System i environment.
Change-management applications use one of two generic approaches to prevent conflicts when multiple programmers maintain the same or interrelated code. Under one scheme, programmers do their work and later resolve problems that result from their overlapping efforts. ARCAD-Skipper follows a more rigorous philosophy. It assumes that the best time to solve a problem is before it happens. ARCAD-Skipper applies additional controls prior to any simultaneous check-out of a source so that developers can resolve potential conflicts in advance.
Organizations that do meticulous testing find must bugs before deploying software, but there’s another type of error that testing can’t uncover because it occurs not in the code but in the way it is deployed. During installation, servers sometimes have to be stopped and restarted in a particular sequence, modules have to be loaded in a certain order, and of course, no updated modules can inadvertently be left behind. ARCAD-Skipper eliminates deployment errors by automating deployment processes, even across heterogeneous platforms. It automatically distributes and installs new versions of software on local and remote machines to ensure accurate implementations of complex enterprise software. ARCAD-Skipper automatically maintains the information needed to build the task lists that support deployment activities.
An added benefit of automating software deployment is that ARCAD-Skipper has the information it needs to roll back programs if a problem is discovered after implementation. ARCAD-Skipper automates the rollback process to eliminate the possibility of human errors and to return the application to a stable state as quickly as possible.
ARCAD follows a strong developer-oriented approach to building its software. The ARCAD-Skipper interface is easy to use and lets developers choose between accessing it in either native or graphical formats as best suits each developer’s work habits. The result is a highly effective and productive ALM environment that is readily accepted by all developers, regardless of their development practices and platforms.
ARCAD-Skipper functionality consists of six different WDSc plug-ins:
- ARCAD plug-in Changer Client, to manage Java and web application development in Eclipse/WDSc and RAD environments
- ARCAD plug-in for Changer, for managing native application change
- ARCAD Cross References plug-in, to access all multiplatform cross-reference capabilities
- ARCAD Request Tracking plug-in, to manage of user requests (e.g., Incident Reports, Change Requests) and internal IT documents (Maintenance Reports)
- ARCAD plug-in for Macromaker, to control all automated functions developers define using ARCAD’s internal macro-language
- ARCAD plug-in Console, for administration of the product.
It’s been said that software development is like building a 747 in mid-air while they keep moving the airport. But — in today’s multiplatform world — it might be even more apt to say it’s like building a plane with parts from a 747, an Airbus, and an L-1011. And not only do they keep moving the airport, but every time you land they make you modify the plane and immediately take off for somewhere else.
The development and management of business applications has never been more challenging. Enterprises are constantly demanding new applications to address new opportunities, customer requirements, and regulatory mandates. These same factors are driving constant change to existing applications as well. So IT departments constantly need to be reviewing, approving, prioritizing, and implementing change requests as quickly as possible to maintain competitive advantage. At the same time, IT needs to make sure that changes don’t adversely affect security, performance, or other linked business processes.
IDEs have evolved in response to these growing pressures by helping development teams do more with less across disparate operating platforms. However, by making it easier for IT to generate more code, IDEs also tend to generate more chaos and complexity in the enterprise application portfolio — which means that they can actually magnify the change-management challenge. Without correspondingly more effective software change- and configuration-management tools, IT may be unable to fulfill its governance and compliance requirements.
WDSc for System i is an extension to the Eclipse IDE that provides System i programmers with the ability to use a single IDE to develop code for System i and Linux, Unix, and Windows servers. This leap in technology also requires a leap in software configuration and process management.
It doesn’t matter what programming language you use, be it Cobol, RPG, or Java, IT organizations that adopt new technologies such as WDSc must support them with appropriate change-management solutions. Ideally, an IT organization’s solution of choice should support development across all of its IDEs, environments, and operating systems. That way, IT can manage change in a simpler and more holistic way across the enterprise.
CA Software Change Manager (SCM) for Distributed, formerly known as CA Harvest Change Manager delivers this comprehensive support across distributed environments including WDSc, Eclipse, Java, and .NET. This lets IT organizations maximize productivity, minimize risk, and ensure high-quality deliverables. So while it’s still hard work to put that plane together in mid-air, you won’t have to worry that someone forgot to re-tighten the bolts after you moved the wing.
Offering an easy-to-use graphical web interface, and an efficient repository-based multi-tier architecture, CA SCM for Distributed enables organizations to automate and manage the application development process, as well as efficiently track and report on software changes, regardless of which platforms and tools developers are using. With the ability to scale from the essential workgroup level applications up to the largest mission-critical enterprise systems, CA SCM for Distributed provides integrations to related disciplines for unparalleled application lifecycle management. CA SCM for Distributed seamlessly integrates with other CA solutions such as CA Clarity, Unicenter Service Desk, and Unicenter Software Delivery to support IT governance, as well as with third-party solutions such as Microsoft Visual Studio .NET and Sybase’s PowerBuilder.
The CA SCM for Distributed Plug-in for Eclipse 3.0 with WebSphere Studio Client for iSeries Support streamlines the development process and enables the use of the CA SCM for Distributed as a team provider or change management provider from within the WebSphere Studio Client for iSeries environment.
The CA SCM for Distributed Plug-in for Eclipse extends CA SCM for Distributed functionality to the System i platform. When installed with IBM WebSphere Development Studio Client for iSeries 7.0, CA SCM for Distributed Plug-in for Eclipse enables developers to carry out change management tasks such check-in, check-out, synchronization, and merging of CA SCM for Distributed change packages without leaving the WebSphere Studio environment.
Developers benefit from an increase in productivity from within their IDE by being able to quickly access code from the repository, to compare and synchronize code between the local system and repository, and to update the repository with the most current version of their work. WebSphere Studio’s language sensitive editors can be used to edit Java and Cobol source code that CA SCM for Distributed manages, as well as to provide access to System i file systems.
The CA SCM for Distributed Plug-in for Eclipse integrates the extensive control of CA SCM for Distributed operations seamlessly within the Eclipse environment. Because the plug-in is based on the Eclipse framework, it can be installed into the native Eclipse SDK, or alternatively into the WebSphere Studio family of IDEs (e.g., WebSphere Studio Client for iSeries). After installing the plug-in, users have direct access to a wide range of CA SCM for Distributed operations from existing views within WebSphere Studio Client.
CA SCM for Distributed Plug-in is an Eclipse Team Provider, offering change management functionality in a manner that follows UI and integration conventions standardized by the Eclipse community. Eclipse Team Providers are required to contribute functionality within the existing Eclipse menus and offer a standard set of change management features, such as project sharing and version comparison.
Users of the CA SCM for Distributed Plug-in for Eclipse can rapidly add files from CA SCM for Distributed to Eclipse projects. This establishes a "shared" relationship between resources in the Eclipse workspace and objects in a CA SCM for Distributed repository. This relationship enables handling in a simple, user-friendly manner of subsequent operations such as check-out, check-in, and synchronizations. Developers execute these actions from the same Eclipse views that they would normally use. The goal is to offer a user interface that makes the presence of a change management system nearly transparent.
The CA SCM for Distributed Plug-in for Eclipse is offered to CA customers as a free, add-on component to CA SCM for Distributed. The plug-in is available via the CA SupportConnect website at supportconnect.ca.com, where customers can utilize easy installation and download updates with the Eclipse Update Manager. Figure 3 shows a typical view of the WebSphere Developer Studio client with the CA SCM for Distributed plug-in installed.
Developers can use with WDSc exclusively. The value add for using WDSc focuses on customers already using CA SCM for Distributed or for those who have plans to move to CA SCM for Distributed as their software change management solution. To that end, to ensure maximum coverage, the ideal software change and configuration management should deliver support for development across IDEs, environments, and operating systems. CA SCM for Distributed enables IT organizations to maximize productivity, minimize risk, and ensure high-quality deliverables for your System i developers, and across distributed environments like Eclipse, Java, and .NET.
MKS helps companies simplify the development and deployment of their business applications. We work with companies both large and small that use the System i and most other commercial computing platforms.
To meet the specific needs of the Eclipse and WDSc user communities, MKS has plug-ins for its Implementer, MKS Integrity Manager, and MKS Source Integrity Enterprise products to facilitate System i development, distributed development, and development tasks and workflow. These plug-ins support version control, source management, deployment, task management, workflow, time reporting, and IT help-desk capabilities directly from within Eclipse or WDSc.
At its heart, Eclipse is an "extensible development platform" as mentioned at eclipse.org. The predominant and most productive use of WDSc is therefore role-specific as a development tool. While System i developers find the open source aspect interesting, of prime importance is the problem that WDSc will solve for them. Our customers usually adopt WDSc to make their development faster and more productive. Some of the favorite capabilities include the LPEX Editor’s Outline View, which greatly helps with comprehension of legacy source code, graphical debugging facilities, and the general ease-of-use in having a fully-enabled RPG- and ILE-aware graphical editor.
To become productive and gain quick acceptance of WDSc, consider the following ideas. First, start with willing "early adopters" on your team to build some initial excitement. Second, provide appropriately sized PCs. PCs sized to run iSeries client access and a basic office application just don’t cut it. And finally, because WDSc represents a new method of doing development in many ways, it’s OK to ask for help. In addition to resources available online from IBM and System iNews, there is an active online community with experts willing help with both the simple and advanced aspects of WDSc. Get involved.
MKS’s commitment to Eclipse and WDSc goes back to the early days of Eclipse. MKS was elected to the Initial Board of Stewards of Eclipse in September 2002 and continues our commitment through our membership in the Eclipse Foundation today. Our first integration into WDSc for iSeries was released in 2003, with many follow-on enhancements since then. MKS experts have spoken at many System i local user groups (LUGs) about the benefits of WDSc for our community. Meeting the lifecycle-management needs of the WDSc and the broader Eclipse community continues to remain a priority for MKS.
When Eclipse was introduced, TurnOver Change Management developers quickly realized that the Eclipse framework would enable them to offer advanced functionality faster. Because IBM had just chosen Eclipse as the basis for its IDEs, leveraging the Eclipse framework would ensure optimum interoperability with those IDEs while retaining TurnOver’s complete consistency with the iSeries Developer’s Roadmap.
In the transition to Eclipse-based technology — a major milestone in TurnOver’s evolution — SoftLanding Systems wrote all the TurnOver functions as a set of Eclipse-based plug-ins, enabling their installation into the WDSc environment. SoftLanding then leveraged Eclipse directly as an application framework for its role-based TurnOver Client. This makes switching between the TurnOver Client and WDSc very easy because they are both based on Eclipse and have the same look and feel.
RPG and COBOL developers must use the Eclipse-based TurnOver components as plug-ins to WDSc to get full support throughout the development cycle. Just as TurnOver’s 5250 version draws on SEU functionality, its Eclipse version draws on WDSc’s LPEX editor and other functionality to provide a full-featured development environment. All of the WDSc plug-in functionality is included in the base TurnOver license.
By redeveloping TurnOver in Eclipse, SoftLanding was able to leverage the graphical and modeling frameworks inherent in Eclipse, and the TurnOver plug-ins take full advantage of WDSc’s graphical environment. For example, we now present TurnOver application definitions as images, which helps developers understand their promotion structures at a glance and from a single view. Customized type codes and systems to which applications are distributed are also readily apparent.
Developers can customize the TurnOver perspective and choose which views are shown (Figure 4), how they are sized, where they are located, and so forth. They can right-click for immediate access to relevant options, drag and drop to add items to a worklist, and keep multiple views on their screen so they can simultaneously see any combination of tasks, worklists, source, or promotion requests. Compare this with 5250 or client/server technology, which offers little or no flexibility in how this information is presented.
The bottom line is if you know how to navigate and customize WDSc, you know how to navigate and customize TurnOver views. By retaining rigorous consistency with the WDSc interface, TurnOver significantly cuts a developer’s learning curve.
The TurnOver WDSc plug-ins offer specialized support for different types of development, including traditional System i and Java development. Working within a unified process, TurnOver gives development teams the specialized tools they need to do their jobs efficiently from the environment they choose. Because all interfaces access the same database, developers are never locked into a specific user interface. This means they can start a change in WDSc and for whatever reason, choose to complete it in 5250 without losing work.
With TurnOver, developers can view assigned tasks, analyze changes, cross-reference and check out objects, add them to a worklist, access change history, launch editors, run error-checking, compile, and promote their work — and never leave their workspace. For example, with TurnOver’s WDSc plug-ins, RPG and COBOL developers can follow the same process as they did in 5250, except they access TurnOver’s source/object control, cross-referencing, and promotion engine from directly within WDSc. The TurnOver Explorer, which shares many design influences with the RSE, provides ready access to every object in every environment for every application — all via a single System i connection. A developer using these tools can see every aspect of a change without leaving this workspace.
Another view is the TurnOver Worklist. Think of the worklist as a way to group items together for a specific change. For example, it shows only the items associated with a particular change, and it shows the status of the items at a glance. If you use the iSeries Project capability in WDSc, you’ll really appreciate the worklist. Once it’s built, you just click an icon to create your System i project and you’re ready to develop offline. The full change process, from check out to compile, is supported from the worklist, and again, all the tools you need are in one place and easy to find.
In addition, developers can access several specialized productivity tools. Consider the Compile Wizard, which lets you test your changes and your compile process without moving anything out of development. You select the group of objects you want to compile, and the compile wizard organizes the compile and puts everything in the right order automatically. It handles all the details for physical files and checks for dependent objects as well as custom compile commands. Everything you need is created in development for you, ready to be tested.
TurnOver’s ILE Cross-Reference Support works with the Compile Wizard to save even more time. The cross-reference information extends to the procedure level, so you can quickly identify all impacted service programs and bound programs and include them in your compile. You can then drag and drop items onto your worklist directly from the cross-reference view if necessary.
Are you working with Java, JSPs, Webfacing, XML, HTML, or other types of artifacts? Just switch to whatever perspective you use for that work, and TurnOver’s version-control plug-ins will manage it for you. Just like System i developers, web and Java developers can access all of the TurnOver features they need from WDSc. They simply open the views they need to do their job. Even though Java and web developers use different tools, they are all supported by one unified process.
TurnOver’s version control supports concurrent development with a copy-modify-merge checkout model. You get the latest version of source from the repository, make your changes, and commit your changes back to the repository. If anyone else has made changes to the same file, TurnOver prompts you to update your local working file with their changes. If their changes are compatible with yours — and most of them will be — you simply issue the update and you are done. If there’s a conflict, TurnOver will tell you and then show you the differences between your version and theirs. This is possible because TurnOver works hand in hand with WDSc’s compare and merge functionality.
However, managing source code is not enough. How do you easily manage the many artifacts generated by traditional Java and .NET applications? The TurnOver Change Monitor automatically picks up any changes in your local project. That means when you make a change to Java source, the repository ensures you are changing the latest version and the change monitor picks up the generated class files. Those you’ll deploy using TurnOver.
The RSE Extensions project, established by SoftLanding in September 2005, is an open source initiative dedicated to creating free add-ons to WDSc. If you’re using WDSc for native System i development, you’ll want to download the latest version of the RSE Extensions plug-in. Each utility runs entirely from within the WDSc 6.0 environment, minimizing the need to open a 5250 session. The RSE Extensions plug-in doesn’t require TurnOver and is free of charge. In one easy download, the RSE Extensions plug-in provides:
- direct access to spooled file output from WDSc
- the ability to view and respond to System i messages from within WDSc
- a perspective for viewing two source-editing windows simultaneously
- graphical compare and merge editors for System I source code (WDSc 6.x required)
- a custom editor for data areas (WDSc 6.x required)
- the ability to display data queue properties and contents (WDSc 6.x required)
TurnOver and its WDSc plug-ins give all your development teams everything they need to do their jobs efficiently from the environment they choose, while reinforcing a unified development process. As the nature of their development evolves, they can shift to new environments with ease.
Thenon Holdings, Ltd.
Thenon’s SEE/Change is a comprehensive, fully integrated i5 change-management system that automatically controls, tracks and audits all activities within the development and maintenance lifecycle. It’s designed to provide an easy-to-use and highly secure method of managing any software activity. These activities include the reporting and prioritizing of problems, allocating work, accessing production objects, determining the impact of change, documenting changes, testing applications, tracking approval signoffs, and moving objects to production and electronic or tape distribution for network and remote installations.
SEE/Change lets enterprise bring mixed-mode (e.g., RPG, COBOL, Java, HTML) development projects under the control of a single change-management system. SEE/Change comprehensively manages all native System i object types. These include source-based and nonsource-based object types such as RPG, COBOL, ILE, SQL functions and procedures, data queues, menus and other application elements. When an object is source-based, SEE/Change seamlessly manages the safekeeping of the source as well as the object itself.
SEE/Change also manages stream files and directories. This support encompasses any stream file type such as HTML, Java, .jpg and other image file types, XML, style sheets, and scripts. Changed managed parts may then be distributed and deployed to System i and other (e.g., Windows NT/XP) servers via common release-control mechanisms.
SEE/Change consists of a number of Managers, shown in Figure 5. Each Manager deals with an individual aspect of the change-management lifecycle. Configuration Manager stores details of the hardware and software configurations and existing operational procedures such as programming standards, object authorities and user sign-offs. Problem Manager registers IT-related requests and problems for review, scheduling and escalation to the development team. Change Manager enables allocation of change requests to programmers, promotion of applications to testing environments, and approval for implementation on production sites. Development manager lets programmers check out source and objects against a change request, determine the impact of a change using cross-referencing tools, and compile and test applications in a controlled environment. Release Manager packages change requests into releases and manages the transfer of the software to production sites.
Audit Manager provides continual access to all object history, including automatic versioning, source documentation and electronic approvals. Process Flow manager (SEE/Job) lets users store the route or path for each change type within SEE/Change. Compare and Merge manager (SEE/One) lets users plan and manage the upgrade of a packaged application. This manager advises users of the difference between each source member in a new version. It compares the base version with the new version from the vendor against the customer’s changed version and provides an impact report.
SEE/Change can be configured for all sizes of IT departments. Each SEE/Change Manager can be allocated to a department or individual to control that phase of the development life cycle. For example, the Release Manager might be allocated to the Operations Department.
If an individual needs access to many SEE/Change Managers, special functional keys are available to link the Problems, Change, Development and Release Managers together.
SEE/Change has a traditional 5250 interface for the Problem, Change and Release Managers. The Development Manager can be launched in either 5250 mode or from within the WebSphere Development Studio client (WDSc) for iSeries Plug-in.
Among the advantages of using the WDSc interface are:
- Windows GUI look and feel (including table views)
- new universal LPEX editor for all source code editing )
- integration with PC development tools such as Code400 and WebFacing )
- ability to develop change requests with both library and stream file objects )
- export code to, or import code from, different development servers )
- an import facility that brings new development projects under Change Management )
- ability to view spoof files can be viewed from within the SEE/Change Plug-in)
- available free of charge from the Thenon website.
The main Development Manager panels (Figure 5) show an ILE RPG and CLP program checked out and ready for development using both the 5250 and WDSc interfaces. The 5250 interface has PDM-style panels that enable editing, compiling and testing of library objects before they’re promoted through the development life cycle. The WDSc interface has a Windows look and feel and supports the same functions as the 5250 interface. The panel below shows program CST0200R checked out to change request 7/02 and opened ready for editing using the LPEX editor.
The main advantages of the WDSc interface are that it enables both library and stream file objects to be developed using a common development environment that has interfaces with many development tools.
The WDSc stream file plug-in enables programmers to check out complete directory structures or single files to a Change Request. The checked-out files can be edited directly or exported to a WDSc project environment. WDSc projects have calibrated development environments for Java, Web, Webfacing, and many others.
The WDSc product is still an evolving platform and anyone considering implementing it should:
- Use the correct hardware configuration
- Install the latest version with all the interim fixes
- Follow the tutorials available
- Accept that some functional equivalents are implemented differently because of the UI.
Unbeaten Path International/Remain BV
Tight as a Drum’s suite of Object Management Software (TD/OMS) has matured into a robust software lifecycle tool from a strong tradition of software change management practices on the System i platform.
Tight as a Drum has a strong usage heritage in Europe. It was invented in The Netherlands by Remain B.V. (remain.nl), a company with a reputation for continuously investing in its products to leverage new technology in the marketplace. The latest manifestation of this investment is Tight as a Drum’s "Diamond Ring" release, which delivers a complete set of plug-ins for the Eclipse/WDSc/RAD environment.
TD/OMS rests upon these three software change management principles. Those are intimate knowledge of the software configuration database, a defined software life cycle, and reliable performance from people.
The first irrefutable law of software change management is: "if a developer makes a change, he/she must have precise knowledge about the consequences for any other system components." Tight as a Drum’s software configuration database automatically records and sustains a complete record of object relationships and version history for managed software components.
The second irrefutable law is that process measurement and enhancement must necessarily begin with a precise definition of how the software lifecycle will be managed. Tight as a Drum functionality comfortably embraces the entire software change workflow: incident registration, requirements management, development, testing, ratification, distribution and implementation of software changes within production environments.
Finally, it doesn’t matter how fancy the development tools are, process integrity rests upon reliable performance from people committed to follow the established workflow.
The five principal plug-ins TD/OMS delivers for WDSc include the following (the yellow-circle footnotes also appear in Figure 6):
- Definitions: this plug-in enables users to define software life-cycle infrastructure [Q2].
- Work management: this plug-in facilitates management of software components.
- Business intelligence reporting: this plug-in provides sophisticated reporting tools.
- Non-iSeries components: This plug-in handles management of components based on the Team API.
- Source repository miner: intuitive front-end which taps information from the user’s source version control system, Subversion, CVS or VSS [Q4].
TD/OMS extends the Remote Systems Explorer so that users can see their tasks and components under development in the RSE. Developers can also launch source editors from there. Even the latest Eclipse technologies (e.g., Mylar, which is an amazing and exciting new development paradigm) are well integrated with Tight as a Drum’s Diamond Ring release.
It’s not uncommon for an auditor to expect quick answers to questions that have never been asked before. Tight as Drum’s Business Intelligence Reporting toolset is now tightly integrated with BIRT, Eclipse’s open-spource reporting system for web applications. That integration enables efficient drill-down to prepare whatever change management information an auditor has requested and to get that formal report printed in just minutes. Savvy auditors frequently don’t accept informal reporting alternatives because they know that just about any report can be fashioned with an artful SQL command.
The integration plug-in for Eclipse/Websphere created by Remain engineers enables a user to select any Tight as a Drum table as a base and then start mining down through Children, Parents, Foreign Parents and Extension relationships picking useful fields from each table during the drill-down process. When the field selection process is completed and the report specifications are saved, the resulting BIRT report arrives with the selected data. That result can then be polished with graphics/logos/whatever to transform it into an impressive "dazzle-the-auditor" final result deliverable in HTML or PDF.
BIRT is one of the top-level projects of the Eclipse foundation and it is a rich report designer. Tight as a Drum’s plug-in for BIRT supports a user report section where a developer can point to any table , select "Create Report" , pick pertinent fields , design the report layout, execute it, and then mail it off to anybody.
At Remain we experienced a significant development productivity gain by using Eclipse/Websphere in our own internal product development process. By leveraging the amazing technology that Eclipse integration brought us, we were able to develop an impressive product functionality boost in just under one year. In our view, we have demonstrated that this is where the open source community meets mainstream business. The new Eclipse/WDSc functionality described in this article is now included with each TD/OMS software delivery but Tight as a Drum’s price remains unchanged.
Mylar is another very helpful development which was conceived and forged by the Eclipse/Websphere community (www.eclipse.org/mylar). Mylar observes a developer’s work activity for the purpose of identifying which information is pertinent to the developer’s task-at-hand. Mylar then employs this task-at-hand context to focus the Eclipse user interface on that information which has been deduced as likely to be the most pertinent to the developer.
The Mylar concept was born from the realization that software systems contain an incredible amount of information; sorting wheat from chaff is typically a substantial productivity drain. An illustration would be the production QRPGSRC source file. It could contain 1,000 or 10,000 source members. A less-experienced programmer must begin by sorting through lots of chaff before being able to accomplish anything productive.
Tight as a Drum makes developers more efficient by displaying just those elements of a system that a developer needs to get a software change into place expeditiously.
Mylar extends this functionality and introduces a new development paradigm by building a task context as developers enter the Eclipse IDE. Every time a developer visits an object, that object is added to the task context. If the developer switches to another task, the context for that task is activated and only the relevant information is displayed without the chaff. Tight as a Drum builds on this paradigm by connecting the TD/OMS tasks to Mylar tasks.
The majority of our customers continue to support and maintain proven applications that drive user interfaces on 5250 terminals. And those enterprises continue to be very happy with that 5250 functionality even though it may not be "fashionable." Many System i users have the traditional view that existing/working/robust functionality delivers more ROI than style.
So our advice is to not throw away your green screens and start coding Java just to be fashionable. Take that step only because you have determined that it will deliver recognizable ROI to your customers, provide a motivational boost for your staff, and make your enterprise more competitive.
If your System i shop is planning to take that leap away from 5250, our advice is to invest a generous amount of time to really learn and appreciate this marvelous toolset. WDSc/RAD development software merits much more attention than a lunch-break install and impromptu click-through.
Finally, don’t expect that your programmers will be productive from day one, or even by the end of the month. As developers gain experience with WDSc/RAD development software, their confidence will grow, together with a realization that this toolset enables tremendous development productivity.
For additional information on Tight as a Drum’s extensive functionality, be sure to visit either the product website or Remain BV's website at the URLs listed below.
John Ghrist is senior products editor for System iNEWS.