The hidden advantages of using a distributed IDE for mainframe DevOps

For most organizations, the need for Continuous Delivery and Continuous Integration is the driving force behind moving to Agile development on the mainframe. The business requirements of needing to continuously update and respond to market needs often outweighs the savings in time and resources, so most DevOps managers don’t consider that in the equation. However, Continuous Delivery on a mainframe can be problematic since many companies don’t have the ability to do true agile development on the mainframe. A distributed agile development IDE may be the solution they are looking for. Distributed agile development offloads the GUI to a desktop environment where the environment is more conducive to IDE tools and interactions with newer tools and technology. In addition, the mainframe proprietary infrastructure can be abstracted on the desktop to further assist developers in creating an agile environment for development, testing and deployment. While the advantages of using agile software are apparent, distributed software provides even more subtle enhancements. Even though DevOps’ goal is unified around software delivery, managers must allocate their resources for the separate functions wisely. For the DevOps manager, he is concerned with more than just the productivity of developers; the operations group and the systems group have their own concerns when embracing DevOps. Productivity on the operation’s side of DevOps has evolved from focusing on stability and reliability to how it affects the bottom line. An Agile Infrastructure is key to providing this productivity, but let’s just focus on how a distributed agile development environment can help first.

For the developers, the inherent advantages of a distributed agile development environment is more apparent, but can often be overlooked:

  • a desktop based IDE with a project based, distributed file system environment provides quicker responses to changes affecting code on the mainframe.
  • File transfer times to the mainframe no longer are an issue, since dynamic updates happen all the time.
  •  Issues with updating the source repository disappear in a distributed environment;  check ins and check outs are a mouse click away.
  •  Complex build environments can be abstracted in an IDE with one click.
  • New deployments can be abstracted into a one click menu item in the IDE.
  • Menus can be customized to fit any environmental or functional requirements.
  • Debugging in an integrated environment with the mainframe not only provides a better view of information, but greatly speeds up the debugging process.

For the operations side of DevOps or the systems department, there are some advantages that may not be apparent with a distributed, Agile development tool. It is just a matter of identifying all the changes to your Continuous Delivery process and how a distributed environment can affect them:

  1. Less overall system resources are used in a distributed development environment, reducing the need for additional capacity planning.
  2. Memory resources are significantly reduced because of the reduction in the number of processes.
  3. Mainframe CPU resources are reduced for a couple of reasons: developers are using Desktop resources to modify their code, and intelligent editors with syntax highlighting or code assist catch syntax errors before the developer sends off the code to the compiler.
  4. Less disk space is required to maintain copies of the source code and temporary files generated by the compilers on the mainframe.
  5. IO is significantly reduced because your developers are using workstations for code development and manipulation and that IO is not being performed on the mainframe.
  6. A lower load on the mainframe results in lower power consumption and lower maintenance costs.
  7. Less load on the mainframe could translate into a reduction in hardware configuration: i.e.  – number of CPUs, Memory or Disks on the servers.
  8. If hardware configurations are reduced, then some software maintenance costs based on the machine configuration,would be reduced as well.

As you can see from this list, a distributed, agile development environment can not only improve developer productivity, but  significantly reduce the resource consumption and enhance the performance of the mainframe. As a systems manager, you should be able to assign costs to these changes and calculate an overall savings. If the systems department is still being operated separately as a profit center, then the distributed agile development savings alone can be used to justify agile infrastructure software to speed up the deployment process as well. In our next blog: How to speed up deployment with Application Performance Managers for DevOps.

How does a Modern, distributed IDE help new developers use OpenVMS?

One of the most daunting tasks ahead of new developers on mainframes is learning all of the operating system dependent infrastructure necessary to do compiles, test suites, and debugging of the code when errors occur. Getting up to speed on that requires a large investment of time and most companies these days don’t have the robust training departments they used to have in the past. Most newbie developers don’t know mainframes like OpenVMS (and don’t really care to if they can avoid it). So the chances of finding top rated talent with this knowledge from college or out in the market are very low. If by chance you manage to find one, they are usually turned off by all of the antiquated job control language they have to learn.

The Common Challenge:

How do you attract and keep new mainframe developers when there are so many more modern agile development systems out there with a more contemporary interface?

The solution:

You make your development environment more modern and provide all of the agile tools developers like: syntax highlighting, code assist, integrated compile and link, integrated debugger and integrated source control. These are the tools new developers need to thrive in their new environment and make them successful. Just as important as the interface is the ability to integrate the desktop and the mainframe in a fast, distributed developer environment. Without this, you are simply developing on a desktop and sending the source code over the network to compile and verify with scripts. By using the distributed developer environment NXTware Remote based on the powerful Eclipse IDE you gain the advantages of a standard IDE with the integration to the mainframe.


In a distributed development environment there are many advantages for both the manager AND the newbie developer:

  1. A modern interface ensures rapid assimilation of the new infrastructure by new developers. By using the Eclipse standard interface for your development environment, you can abstract the infrastructure into menus, list boxes and wizards with one click functionality. The developer can quickly learn your environment and make progress on what you are paying them for: development.
  2. Adopt agile development teams to breathe new life into aging 3GL applications; enabling scrums to make changes easily, one-click compiles and integrated testing or automated builds just as easy as other platforms.
  3. Integration with DevOps deploy and manage functionality with NXTware Deploy and NXTmonitor makes it easy for new developers to deploy and test in an enterprise environment. With integration of your standard compile scripts into Eclipse menus, a newbie developer can be compiling and running existing applications within hours of introduction into this environment.
  4. Ease of use: a distributed interface with familiar Eclipse screens in NXTware Remote makes mainframe based source projects on the desktop easier to develop with. Abstracting much of the infrastructure they need to use to develop and test code minimizes the knowledge required to develop on this platform.
  5. Assist the learning process for 3GLs with Code assist and code complete; provide syntax highlighting editors to help newbie developers on 3GLs learn the language quicker.
  6. Integration of newer technology with legacy systems is made easier in NXTware Remote, which supports both.

More control

With a modern IDE like Eclipse, you have access to all kinds of management tools like software project management plugins and reviewer projects.

  1. Increase productivity by providing leading edge tools for developers and giving them an environment which keeps them more engaged leads to longer retention and developing more innovative features for the user community.
  2. In addition to superior developer tools, integrated software development project management tools in Eclipse enables managers to use the same interface and manage the project manager’s control of tasks, enable project reviews and provide timely feedback from developers.
  3. IDEs display more information in a more compact, easily read medium and multi-frame environment enables developers to quickly fix problems in less time and more efficiently.
  4. By allowing junior developers to quickly learn a new environment, it frees up your senior developers to work on blue field projects and analysis on how to improve existing software assets.
  5. Time is always the biggest issue development managers have on mainframes like OpenVMS. By improving productivity with modern tools for the developers, the turn-around for new features is reduced, making Continuous Delivery a reality and this makes your company more competitive.

Helping bring in new developers is only one of many advantages of the NXTware Remote Solution. Reducing costs on development and increasing the speed of deployment of new applications are significant too. In addition, the systems department can see tangible benefits as well, and that is the subject of the next blog: The hidden advantages of using a distributed IDE for mainframe development.

How NXTware Remote helps managers extend the life of their OpenVMS systems

OpenVMS is a very robust Operating system and many OpenVMS users have an application which runs so well on this platform that it is difficult to replace. Accordingly, most managers realize they need to extend the life of the application on this platform because it provides so much value to the company. Paramount to its long term survival is making it easier to modify and maintain, which is one of their biggest needs.

The Common Challenge:
How do you maintain and improve a legacy application when the operating system expertise upon which it is based is disappearing?

The solution:
You solve this by getting “fresh blood” developing on your application and by leveraging environments with which they are familiar.

This can be done by using an Open Source based IDE which can be modified to support your legacy OS infrastructure and the 3GL languages they are written in. With the right tool you can extend the life of the application and ensure it is properly maintained for the future.

  • Enterprise IDEs like NXTware Remote are developed for this need with Eclipse support on legacy systems in a distributed development environment.
  • Integrated tools like source library management, code assist and code templates makes it easier to adapt to a new environment.
  • NXTware Remote leverages a distributed integrated development system for OpenVMS and linux and it solves the problem for managers who can’t find OpenVMS developers for the projects they have.

Time is always an issue and one of the biggest challenges development managers have on mainframes like OpenVMS is finding the expertise in the marketplace to implement on-going development now.

  • Market changes are happening at an increased rate, so changes in your mainframe applications need to address those changes in order to remain relevant.
  • In addition to a need to augment your staff, managers have to worry about eventually replacing their existing staff who are getting older and closer to retirement with quality, trained developers.
  • What managers need are younger, agile developers who can work in SCRUMs and familiar with the latest IDEs that run on Windows, MacOS or linux computers. That expertise is readily available and at competitive prices.
  • For OpenVMS developers, that knowledge and experience is hard to find these days since it is not taught at universities and there are not many in IT that want to learn a legacy system using green screens and line editors.

So in many cases these projects are delayed because the in-house developers just don’t have the bandwidth to keep up with the changes that are being demanded by the user community. Several dynamics tend to happen:

  • The developers you can find to join your team, find it hard to learn enough to help the existing staff (infrastructure training only slows the project down – if you had the time to train them).
  • For legacy applications written in 3GL languages like COBOL, Basic, Fortran, Pascal and C, there are a limited number of consultants or developers available who know OpenVMS and those languages as well.
  • Those that do have that skill set may be very expensive, unwilling to adopt to your infrastructure or unwilling to relocate. Most of the established developers are already working for other companies, making it harder still to recruit the talent you need.

Your best option is to recruit College level 4GL programmers with no OpenVMS experience and teach them how to develop on OpenVMS with NXTware Remote. By minimizing the new interfaces developers have to learn to start developing on the mainframe, you can abstract the OS dependencies so that file editing, compiling, testing and debugging on a mainframe are as familiar as doing it on the workstation.

This is the NXTware Remote solution and we can show how this reduces the time to learn development on a new OS. That is the subject of our next blog.

Why NXTware Remote?

Why NXTware Remote?  If your company is considering using NXTware Remote you may be asking yourself this question.  We could list a bunch of features that eCube finds important but we think it would be more beneficial if you knew what features our clients find the most beneficial.

At the 2013 OpenVMS Boot Camp, ICC conducted a presentation on our behalf.  With 50 developers using NXTware Remote, they can provide a unique view on the product.  ICC believes there are two major NXTware Remote advantages:

  1. NXTware Remote comes with advanced editors that increase and improve the quality of the source code developed.  Advanced editor functions identify errors on the code as they are written, parse the source into meaningful parts, and allow content assist of code and templates.
  2. The development process is done on the familiar and universal IDE of Eclipse and because of its plug-in architecture, integration with many advanced products and tools is allowed.

In this post we will discuss ICC’s opinions on 5 of NXTware Remote’s advanced editor functions: parsing, syntax highlighting, source code templates, search & replace, and bookmarks.  In a future post we will talk about content assist, mirror files, editor preferences, macros, and keyboard shortcuts.

NXTware Remote Advanced Editor Function 1: Parsing
The first advanced editor function identified by ICC is parsing.  With parsing, source code is divided into sections that are displayed next to the editor on the outline tab.  This makes it easier to navigate between sections because you can press the section name on the outline tab.  You can also sort the section names in alphabetic order.  According to ICC there is “no need for a long search, just click.”

NXTware Remote Advanced Editor Function 2: Syntax Highlighting
The second advanced editor function ICC mentioned is syntax highlighting.  Syntax highlighting emphasizes the reserved words in the source code.  The emphasized words are displayed in a different color or font style configured by the user.  According to ICC, “the code is displayed in a more clearer and understandable way and the different words that construct it can be easily noticed.”

NXTware Remote Advanced Editor Function 3: Source Code Templates
Source code templates allow you to define common source code templates that are repeated several times.  Input, constant, and cursor position variables can be added to a template.  Once a program is completed, it can be defined as a template.  As ICC says, “why write the same thing over and over again?”

NXTware Remote Advanced Editor Function 4: Search & Replace
By pressing Ctrl + H, you can search for and replace text.  The search can be done on different levels including workspace, a set of chosen components, current project, or current file.  The search results are displayed on the search view and are reachable when you press them. In the search scope, the match text will be highlighted on all of the files.

NXTware Remote Advanced Function 5: Bookmarks
Bookmarks allow you to mark a single file or a single line inside a file.  All of the defined bookmarks are displayed in the Bookmarks view.  To access a single bookmark, you can click on it in the Bookmarks view.