How do you maintain your company’s programming skills on legacy systems?

The future of many legacy applications are frequently determined by one or two decisive events that happen during the lifetime of a critical application and it is usually not related to the performance of the software itself. Normally, the software lifecycle tends to conform to two bell curves as related to return on investment (ROI) and risk (of failure). Over time, the return on investment and subsequent risk rises as a significant amount of time passes. This is displayed in the graphic below:

Application Return on Investment and Risk over time

More often than not, it is the risk is associated with keeping the skills needed to keep the application healthy that is the biggest issue. Often an event occurs related to the software maintenance or management staff that causes problems for the future of the application. As an integrator with many years experience, we have seen this dynamic play out many times before: a company’s critical application that was developed and maintained for many years very successfully suddenly reaches an impasse on its future. It can be traced back to one or two events:

1. a key developer/engineer with in-depth knowledge of the application retires or leaves the company. Suddenly, the company in unprepared to handle future maintenance on the application.

2. There is a radical management change due to promotion, M&A or retirement. New management comes in and decides that the old system has to go.

As a result of either of these scenarios, the management decides to re-evaluate the worthiness of keeping the application and cites rising costs as the driving factor. While this can be used to drive management’s agenda to replace the application, it is usually the risk or loss of technical expertise that seals an application’s fate. Replacing the skills of a long time developer or maintenance analyst is difficult even if the application is well documented and maintained. If you add the requirements of a legacy language like COBOL, Fortran, C, Pascal or Basic, the task becomes very challenging since these programming skills are scarce and with very few exceptions, they are not taught in universities or colleges. Add to that the liability of using a legacy platform, and you have a good case for application replacement. In addition to the risk, the biggest problem is cost, which is sometimes ten to twenty times the cost of yearly maintenance. Totally replacing an application that is working smoothly but has a foreseeable maintenance issue in the future makes it very hard to justify immediate action to upper management. They are averse to spending money on an application that hasn’t cost them a lot of money over the years.

So you are stuck with maintaining an application with little or no programming expertise on the platform or the language the application is written in. You have the departing analyst’s salary in your budget and if you can find a consultant with the expertise, you can hire them part time, but even that is a temporary fix. So what do you do?

If a programming course for the language does not exist, you can try to get your consultant to teach your new developer the application language basics. How do you get the newbie trained in the quickest possible manner?  Here is a solution: use the Eclipse-based NXTware Remote for COBOL, Fortran, C, Pascal and Basic development. NXTware Remote provides the ability to develop in legacy languages with intelligent editors on Windows, Mac or linux in a distributed development environment. Specifically, the NXTware platform contains an engine that runs on the legacy system and communicates with the desktop IDE, interprets commands to manage the source files, compile, debug and execute the binaries (executables) on the legacy platform remotely. The process of learning a new language becomes simpler since the newbie is using an environment they already know from Java developer classes. The interface breaks down the barrier to learning and provides an environment with which the developer is already comfortable. The new developer learns to program in the legacy language remotely without having to learn the legacy job control language or any of the infrastructure of the mainframe.

By modernizing with NXTware Remote you extend the ROI

In this way, a neophyte can learn the structure of a legacy programming language and not worry about the mainframe infrastructure necessary to compile and test the code.  Using this distributed development environment can jump start your legacy application’s entry into newer development technologies.

Reasons why outsourcing of applications maintenance and development doesn’t save you money

In response to rising costs of maintaining their source code, many companies are making a move to outsource the development and maintenance of their legacy applications. In the climate of managers having to do more with less and trying to find ways to save money on the IT budget, the outsourcing solution can be a quick fix for a lack of legacy IT management skills. It looks like a good cost saving move initially since the cost of salaried developers along with benefits and office space required to house them is a substantial cost savings. However, with a little research into the application itself, you can find similar reductions in costs and address the substantial risks that may not be accounted for in outsourcing. Here is the question that you need to ask before making this decision:

Are the high costs of application maintenance and development due to inadequate documentation, poorly maintained code or poorly designed code?

Poor maintenance of even the best written code can be the cause of higher maintenance costs due to the ripple effect: when a change in one section of code causes a ripple effect and breaks other sections of code.

Another cause of high costs may be poor documentation on the design or operation of the application. A lack of understanding on how it was designed can lead maintenance programmers to hack in quick fixes rather than try to understand the code.

If the code is poorly designed and not modular, then maintenance costs will soar whenever changes are required because the code was not designed to handle it; sections of code may need refactoring, duplicate code to introduce new features or fix existing ones.

Can addressing these three areas significantly lower your maintenance costs? It should. In any event, all of these potential problems should be resolved before you take that step to outsource the application maintenance; this will make changes easier to integrate, ensure the existing system is properly documented and running within its current specs. The maintenance problem is only going to get worse if a disinterested party takes charge. If you don’t think there is a maintenance problem, then here are some questions you should also consider before outsourcing:

Does the outsourcing company provide the same service to your competitors?

  • Is it is possible that your provider is outsourcing support of similar applications for your competitors? The knowledge they acquire from maintaining your application might provide an insight into refactoring a similar section of code for a competitor’s application.

How will your source code be maintained once it is out of your hands?

  • Does the outsourcing company provide comparable security for your code in their possession as your company might employ? What about proper version control? How much training do they have in programming? Do they do code reviews?  How many people have access to the code?

What is the quality of the workmanship provided by the outsourcing company?

  • A modular design and the intelligent construction of the application are the most important factors in application maintenance cost. The question becomes whether or not your outsourcing company will use quality developers to maintain your code. Most importantly, the lack of vested interest in the application’s success carries even more risk. Having knowledgeable, expensive in-house developers may be a bargain if you consider what damage a neophyte can do to stable, running code.  A lack of familiarity with the code and/or multi-tasked developers might result in hastily installed or poorly designed patches to the application, increasing maintenance costs and making the code harder to read or modify in the future. Outsourcing companies tend to have a high turnover rate and this correspondingly increases the risk of failure.

Outsourcing stifles innovation

The biggest loss to a company from outsourcing is the loss of innovation. As many computer systems managers will attest, innovation is often a by-product of maintaining a system, seeing problems that arise and resolving them. The process of discovery, investigation and resolution of a problem often leads to a better understanding of the cause and developing new technology to circumvent or prevent it, making the process more efficient. Assuming a comparable skill set between the in-house developer and the outsourced developer, both might run across this opportunity to improve the application. While your developer might inform his management or simply implement the improvement to see what affect it has, the outsourced developer has no incentive to do it. For the outsourced developer, improving the quality of the code is not usually included in the terms of the outsourcing contract. The outsourcing company’s goal is usually tied to closing as many problems as they can, as soon as possible; which in some cases leads to improper handling of bugs or problems. Improving the quality of the code or increasing performance will reduce the number of bugs and lessen maintenance requirements on the application – that might possibly reduce the scope (monetary compensation) of the outsourcing contract. Depending on the outsourcing agreement, that might lead to a reduction in the cost of the service. Most outsourcing companies are not interested in that.

Why is Legacy Software Maintenance so difficult to manage?

Many managers have a problem managing legacy software systems and this article will discuss some of the reasons for that. Almost every company that has been using computers for any length of time has developed some in-house software that meets a very specific need that cannot be met by COTs packages. Anytime you deploy a software system into production, it becomes a legacy system by definition, and for good or bad it becomes part of the company’s portfolio. Some of these systems become very successful and enjoy a long deployment cycle.

Almost immediately after the new system was deployed, however, the most skilled developers on the project leave to develop on other projects or find bigger challenges with other companies. Unless the system design was well documented, most of the knowledge of the application left at that point. As the application entered maintenance mode, fewer and fewer developers who knew the design of the original system remained. Over time, the application evolved from its original version usually in response to business and technology needs, and it continued to provide a greater value for the company. These are the kind of applications which companies decided to keep.

Eventually, the application begins to show signs of age and the technology upon which it was based becomes obsolete and incapable of supporting the new business requirements. Patching the code for new features is no longer a viable alternative. Your legacy application has evolved to a certain point, but now the changes needed exceed the constraints of its design and it has become brittle and resistant to further change. This is a normal evolutionary process and something that every organization has to respond to.

Unfortunately, as your application has evolved, the skills of the developers that maintain it haven’t always kept up with the latest technology. With more and more new features being provided by open source, third party software and new technology, managers find themselves looking for outside help to bridge the technology skills gap. They run into problems fitting these developers into their legacy environment because of a mismatch of skills. Newer developers usually lack the background in legacy systems required to understand the design of the application and there are very few places they can pick this knowledge up. The older developers who have been maintaining the old system often don’t investigate the new technology since it is not a part of their job description.

Along with the maturation of the application, the company’s perception of the importance of the developer is reduced, so the resources to keep these skills are also reduced. Pretty soon the expertise needed for legacy development has evaporated and the knowledge of the history of the application is reduced to one or two maintenance programmers. Their strength lies in the understanding of the history of the application and not necessarily in the inherent design. The design knowledge is gone but the need for redesign will require this same type of skill (usually a mismatch with the skill set of the remaining developers). In order to extend the design of your legacy system, you need the skills of a highly skilled developer and to attract this type of developer, you will need to have a modern environment for them to develop in.

This is the problem many companies with legacy systems face: the business logic that legacy systems perform and value to the company needs to be retained and extended because the cost of any other option (i.e. a re-write) is too risky and cost prohibitive. Many CIOs have faced this problem and have analyzed and assessed their inherited legacy systems only to defer any changes due to the risk. That risk is now becoming greater with the passage of time as the technology gap widens and the expertise that is currently maintaining the legacy system is getting close to retirement age. The talent pool of legacy developers is shrinking every year and it is not being replenished with college graduates who are willing to learn this old technology.

While newer technology can replace much of the functionality of legacy systems, the business logic which it performs cannot be replaced. So the problem you have is finding the right mix of developers and technology tools to implement a new design through integration. What is the best way to achieve this goal? Perhaps there is a solution already out there – check out this video:


What are the DevOps Benefits of Application Orchestration?

From our previous discussions, you can see there are many tangible benefits from using Application Orchestration for DevOps. Not only do you leverage the monitoring benefits of a GUI, but you also create the intelligence you need to quickly deploy and run new applications. The most prominent benefit is for the operations staff because now they can have a tool which can show them the current health of the applications and they can manage problems without needing the developer’s help. The DevOps engineer now has the ability to migrate the exact infrastructure intelligence from one system to another and the developer is now freed from babysitting the application for the first few months while operations learns how it works and how to resolve problems. The intelligence created in AO to pre-define and orchestrate the interactions of discrete components that make up complex applications provides the basis for these benefits. As many DevOps engineers know, modern enterprise applications can often contain inter-dependencies with other applications and components and are sometimes a part of a Hybrid IT solution that can make them difficult to manage. As many DevOps engineers can attest, just restarting a process that has died does not necessarily resolve the problem. Some complex interactions between these components can be difficult to isolate and that can slow down or even stop the effective deployment of a new application. Since many of these interactions cannot be “discovered” and are not be obvious to operations, they are a significant barrier to the successful DevOps operation for Continuous Delivery.

Abstracting Complexity with AO

If we consider the overall goal for DevOps, we want a tool to deliver new software versions quickly and effectively which means the new software needs to be deployed, started and tested as quickly as possible. Application Orchestration is the solution that can simplify the deployment and management process by abstracting infrastructure complexity with easy-to-use GUI-enabled, dependency tools which can create relationships between components. The component status will then automatically determine which modules are affected. With an effective display, application status becomes more apparent and precise, thus making error detection much easier. Similarly, corrective action needs to be automated based on the infrastructure or surfaced in the GUI for the operator to affect rapid response. To achieve this level of infrastructure intelligence, a number of features are needed for Application Orchestration, including intelligent display and control, scalability and portability.


Visualization of the application is important for understanding everything else in Application Orchestration. If the true status of an application is to be understood, its infrastructure and relationships need to be represented in an intelligent display with readily available controls for management. By providing a navigation frame which itemizes each component and provides a drill down into each, a multi-tabbed display affords the DevOps engineer a wealth of information with a click of the mouse.


Perhaps the biggest challenge for operations is scaling up an application from development to production usage. AO needs to provide the infrastructure to readily modify the throughput capability of the application. Creating objects with its own start/stop/dependency properties enables AO to replicate each component in the configuration: i.e. copy and paste the objects inside the configuration to enable scalability.


The portability of this intelligent infrastructure is a necessity for DevOps, speeding up the deployment process and preserving the intelligence needed to manage it. The knowledge required to manage the application has to be consolidated into a configuration file which can be exported to other systems.

Given the features which we have identified here in this discussion, I think we have presented a good case that Application Orchestration will have a positive impact on how application are deployed and the ease in which they can be managed on enterprise systems. For more information on this capability, check out our further discussion of Application Orchestration features in our next blog. For a free evaluation of an Application Orchestration product from eCube Systems, click on this link:

What is Application Orchestration and why does it help DevOps?

Developers in a DevOps environment are always looking for vendor solutions to help them hand off the management of their deployed applications. One type of software is particularly suited to provide this functionality and it is known as Application Performance Management. APMs can not only start and stop processes in a timely manner, but they can ensure processes are restarted when they fail. While most APMs are based on managing newer languages only on contemporary platforms like Windows and linux, these script based solutions do provide a valuable infrastructure to help companies manage and deploy new applications faster. Many DevOps vendors provide this type of solution completely with their own proprietary scripts which require a significant investment of time to get it right.These scripts do a variety of detailed functions like setting up the file system structure, copying files and creating VMs to host the new application. While much of this is very useful, it does not solve the biggest DevOps problem of fixing application deployment run time issues. That is where APMs come in and specifically a type of solution that is a hybrid of Application Performance Management systems known as Application Orchestration – it augments the APM functionality with a unique approach:

  • capture the developer knowledge with rules in a configuration file
  • provide GUI controls needed to make DevOps much easier
  • Visualize applications with easy to understand displays
  • Enable scalability of applications by operations with performance groups

This paper will outline these enhancements to the APM model and show how AO helps the DevOps engineer understand and modify the application infrastructure, which is essential to managing enterprise applications where the problems can be complex and timely response is critical. Commercial DevOps tools like Puppet Labs and attempt to solve this issue with scripts which provide the ability to set up and deploy an application to the enterprise, but fail to manage them effectively. This is because they are script based that are inherently:

  •    Developer written and maintained
  •    Statically written, but may require frequent changes
  •    Designed to interpret the effects of problems with constant polling, and
  •    Execute complex logic to determine the appropriate actions to remediate

Using the Application Orchestration approach, the application infrastructure intelligence is captured in a configuration file so the retry logic, timing, dependencies and relationships within the application can be used to resolve issues. In many cases this knowledge can predict where problems will occur and resolves the cause of the problem before the application user sees the failure. By managing the application through a configuration file which captures the infrastructure, the intelligence is built into each module, making it easier to replicate for scalability and facilitates its display in a GUI. Component dependencies are captured for each module so the effects of problems are automatically propagated to each affected component, making it easier to display accurate status and predict problems before they surface to the application users. The GUI which displays the configuration also gives the DevOps engineer the confidence that the application is running smoothly and that they will be notified proactively should potential issues occur. This approach differs from the dependence on scripts that look at the effect of a problem and then execute copious logic to find where it originated so it can determine how to fix it.

In our next blog, we will itemize the features and the benefits Application Orchestration can provide for DevOps.



How to speed up deployment with Hybrid Application Performance Managers

In our last blog entry, we discussed the hidden advantages to using a distributed IDE for enterprise development, but that is just the tip of the iceberg. To fully realize a Continuous Delivery (CD) environment for legacy systems, you need to be able to deploy the new applications just as quickly as you develop them. Moreover, you need the ability to seamlessly transfer a running application in development to production without extensive delays. We can all agree that it doesn’t make sense to improve the processes around the development of new versions of your application if it takes months to test, QA, and deploy the application to your users. There are a number of obstacles that can cause delays in deployment, but let’s focus on the ones within your control; ones that you can improve readily or avoid if they aren’t integral to the Continuous Delivery process. In order to limit the scope of this discussion, let’s assume your company has a robust testing environment and an adequate testing strategy. Let’s also say the following assumptions are also present:


  1. The development process makes significant changes to the infrastructure that are not all documented.
  2. The systems to which the new applications are deployed to are not similar to the development environment.
  3. The documentation of the application infrastructure does not provide enough information to resolve issues.

The Common Challenge:

Given all these assumptions, how do you make the deployment process for a new application easy and as streamlined as possible?  How do you avoid environmental and load issues when deploying a new application?



If you believe the majority of problems in deploying a new application is the result of resolving differences between development and production or QA, then the solution we are about to discuss will be of interest to you. Our proposal to speeding up the deployment process for new applications is to not only capture the development environment, but the developer’s knowledge of the application as well. By that we mean: capture the developer’s knowledge of dependencies and subtle timing changes in the new application. Often the integration of new modules requires more time to start or are dependent on configuration subtleties. By capturing this information you can reduce potential errors and ensure that testing and operations can concentrate on their goals instead of trying debug the infrastructure. In the traditional sense where the developer starts and stops the application with scripts, the majority of changes involved in moving from development to operations is centered in these scripts. The process of maintaining these scripts is the single most difficult task in migrating the application. The migration of application’s components and structure to the target system is trivial in comparison to modifying the scripts for the new system. Given the complexity of some applications, this is the place where changes are typically needed for a variety of reasons and the developer is usually the only one who knows what the issue is. What if there was a better way to capture this infrastructure so that it is portable, more adaptable to new systems, and easier to modify?

On more modern systems like CentOS and RHEL (and other Linux variants) and with Java applications, Docker is an excellent example of how the exact image of the OS can be created and the application can be captured in containers. A set of docker run commands with bash provides the install and run commands necessary to start individual apps. Docker also has restart policies to restart a container automatically when Docker restarts or if they exit. More complex applications can be started with a bootstrap also run in Docker. Even with these systems, the scripts sometimes need some changes. Scripts of these type are often complex with individual commands which usually require a programmer or systems engineer to modify and maintain. While this type of model might work well with Java, other languages like 3GLs present problems since they are not container based. One promising solution can be found in leveraging an Application Performance Management (APM) hybrid known as application orchestration. This APM hybrid is designed specifically for managing the application infrastructure: application startup and shutdown, using the developer’s knowledge of dependency and starting order, all captured in a configuration that can be replicated. Application orchestration is best described variant of the Application Performance Management software model, since it has no classification of its own. The APM model specifies several criteria useful for managing multiple processes in an application.

The Application Performance Management approach

Application Performance Management tools are a classification of software that facilitates monitoring applications. There are a few commercial tools that provide some but not all of the features that APMs are intended to provide. In this discussion, we are looking at the provision of key services that afford a DevOps environment significant advantages, ease of use and speed to deploy. While commercial APMs are focused on monitoring software to ensure performance, we are targeting features that provide some applicability for solving DevOps problems and specificallly for speeding up the move to production. If we look closely at these features, we can see how APM features can provide the base services that are needed for application orchestration that is essential to DevOps systems:

  1. End User Experience – in the world of application performance, this feature is probably the most important. In the DevOps world, we would argue our end user is the development and operations staff. Using the APM active monitoring feature would provide a great benefit after the deployment and would most probably provide the foundation for defining and documenting the variables in play during deployment. The EUE feature not only benefits the application end user once the deployment is complete, but it would improve the experience of operations and developers who need DevOps tools during the deployment process.
  2. Runtime application architecture – this feature is essential to managing application performance and greatly benefits the DevOps intelligent infrastructure because it is the best way to capture the components and put them in a configuration that can be managed. However, we believe that management is best done when you can visualize an application architecture is through a GUI console, rather than through scripts. A GUI can visualize the underlying application infrastructure by exposing each component and its sub-components and their dependencies. The key feature here is Application Dependency and Discovery, which is useful in managing the application and assisting the orchestration of the application during startup.
  3. Business transaction –this is a more obvious feature when it comes to describing tools for monitoring and performance purposes. In a DevOps tool, the APM business transactions feature is important because it reflects the application’s overall health which may be performed by the various discrete components. This information needs to be captured so that it can be monitored actively with health scripts and actions can be taken in the event of failures or degraded performance. Important application dependent transactions need to be identified so test cases or health scripts can be used to validate the accuracy of this feature.
  4. Deep dive component monitoring – another key feature that is quite important to the DevOps world because it relies on an intelligent infrastructure which is capable of reacting to external forces and can detect and fix problems with the application. In order to successfully accomplish this level of automated management, a deep dive into each component and its dependencies is needed to determine the scope of modules affected and handle any contingencies. It should then follow that the ability to capture this infrastructure intelligence will make replication of the environment for operations even simpler.
  5. Analytics and reporting – while a secondary feature of APMs relies on analytics and reporting to provide performance data, DevOps requires application orchestration, which doesn’t depend on this level of metrics to be successful. Analytics used in conjunction with application dependencies, however, are useful in determining application health and are useful in solving system dependent resource issues which may affect the application. In the DevOps world, the goal is to get the application functioning and running without issues. Looking at the analysis of resources is good for spotting trends and making adjustments for the application, but you often have application dependency issues that affect application performance. If you want to focus on the internals, application log files are the primary source of reporting application health for DevOps.

If an APM addresses each of these needs, it would probably be an effective DevOps tool. However, one very important issue is left unresolved: how does the knowledge of the application infrastructure get transferred to operations for a new environment? Is the documentation provided by development sufficient? Are you expecting the DevOps engineers to understand the intricacies of a developer’s scripts or do you expect your developer will be assigned for an indefinite period of time to operations to shepherd them though the process?  If you are looking to incorporate commercial APM software into this process, then you should look at maximizing the impact of each of the APM features in speeding up Continuous Delivery. Do your homework and figure out what you need and incorporate those requirements into a hybrid solution for CD. Most likely you will come up with a set of requirements that needs a specific solution: Application Orchestration. Stay tuned for our next post which explores this idea.


Intelligent Infrastructure for DevOps: Using a GUI to manage and monitor instead of scripts

Application Performance Management tools have been around in one form or another for many years, mostly operating anonymously and unnoticed. While most of these tools were home grown, there were a few vendors who supplied generic APM tools. These tools addressed application infrastructure needs in the background and were not considered a strategic part of IT; they kept applications running with a series of scripts developed by the architects of the applications. Since this software is neither development nor operations specific, they were often not claimed by either department. Until DevOps became a buzz word, they operated under overhead accounts or were assigned to different departments in spite of the job that they did. However, since Agile Development has become mainstream, the need for an intelligent infrastructure and the unification between Development and Operations (DevOps) has refocused attention on APM tools. Agile infrastructure is now a necessity to ensure the rapid and accurate deployment of newly developed applications as fast as the Agile Development tools that were used to implement the new business logic. For years companies have developed their own script based infrastructure and due to internal changes it has evolved into obsolescence over the years. This has happened for a variety of reasons, but mainly because the scripts were written for one purpose and once the author departed, no one knew exactly how it worked – so it fell into disrepair. Out of this need, many companies have turned to DevOps companies like Chef and Puppetlabs, et. al. that have developed command line, template or script based tools to provide this intelligent infrastructure, primarily focused on the linux platform. Some of these scripts are Ruby based, but in most cases the scripts and templates are a proprietary language. These proprietary scripting languages can perform many different intelligent functions to handle deploying new applications and even creating new systems to deploy them to. The advantages of this approach is that scripting language is very powerful and simple to learn, making the ability to generate intelligent infrastructure easy to implement and deploy.

The problem with using scripts is that they are:

a. written to handle a specific action, requiring constant change whenever the infrastructure changes.

b. written for specific platforms, so one change has to be propagated to the others.

c. requires knowledge of the infrastructure.

d. requires knowledge of the scripting language.

More complex scripts becomes difficult to read and understand beyond a few lines of trivial operations, which makes it hard for maintenance by anyone other than the author. Unlike the goal of DevOps, which is intended to unify Development and Operations as a team with one goal, scripting languages requires an analyst maintain the scripts so that new development can be seamlessly managed or deployed. Operations typically does not have this knowledge and it can be difficult for them to develop this skill (not being programmers as such). In order to facilitate a DevOps environment, the complexity of the scripts required to implement this infrastructure intelligence needs to be abstracted into simple actions so that operations can use it. This is usually accomplished with a Graphical User Interface. Historically, Operation’s goal is to keep everything in system running smoothly and applications are an unknown area: they perform business logic on data, consume resources indiscriminately and typically don’t handle system problems very well. So operations rarely understands the infrastructure of each application; they simply monitor it from the system resources aspect to see if there are any problems. Using scripts to automate this function is helpful, but tools to display the results are arcane. They are more familiar with desktop tools that have menus and displays because they are easy to use, easy to understand, and easy to modify. Operations is familiar the system operations and how it provides resources to applications like CPU, Memory, Disk and Network speed. These are things they can understand using commands for. However, for DevOps to be successful, using command line scripts  or knowledge of the application infrastructure should not be required to manage applications. What is needed is a tool that manages the infrastructure from the application side and notifies operations of any potential problems before they impact the overall system.

Now application management and monitoring tools have been around for many years and a few of these existing tools can be adapted to meet this need. One such tool is a third generation application management tool called NXTmonitor. NXTmonitor’s heritage comes from the Open Environment and Borland tools known as Netminder, Appminder and AppCenter. These tools evolved from simple monitors to a three tier architecture (presentation, business and database layers) to manage applications with a rules-based configuration file to specify each application’s environment. By leveraging middleware to facilitate multi-tier communication for agents and master servers, these tools were built on a fast, scalable infrastructure that enabled UNIX and Windows applications to be managed by an independent middle tier through a GUI presentation layer. The best description of this powerful tool is Application Orchestration: a tool that enables the definition and maintenance of complex applications and powerful monitoring capability with definitions of interdependencies across multiple platforms. This allows a complex structure to be captured in an intelligent, XML based configuration file that is built with the help of a Graphical User Interface (GUI). By recording the structure required to start the applications across multiple nodes to a configuration file, NXTmonitor can replicate the development environment exactly and even scale it up for production use. The use of environment variables enables NXTmonitor to assign variable infrastructure components to values that can be changed, making the tool easy to use in defining and replicating a complex environment. When the environment changes, these variables can be captured in environment variables which are different for each environment.

NXTmonitor is the next evolution of DevOps infrastructure tools – managing the deployment of a multi-tier application with a GUI console which can define the intelligent infrastructure needed for agile development. Unlike other DevOps tools, NXTmonitor provides a full featured APM that supports application orchestration across multiple platforms like IBM i-series, z-series, OpenVMS, Windows, and UNIX in addition to Linux. Application Orchestration is a relatively new term: it is the ability to start a complex application consisting of multiple, discrete components that are interdependent in a concise manner so that the application can be ready to process information in an orderly manner. In essence, Application Orchestration captures the developer’s knowledge of the infrastructure in a configuration file that can be used as a playbook for starting up applications. It is intended to be displayed and monitored by operations staff, with mouse actions that allow them to easily inspect or modify the configuration for scaling or performance purposes. Action scripts and Timers enable custom execution of actions designed to resolve runtime problems and increase performance. The definition of Performance groups makes scalability simple and easy to modify capacity, failover and service levels.

One of the key benefits of using NXTmonitor is that the NXTmonitor Console GUI is designed to appear the same across all platforms and perform in the same manner regardless of the desktop software or the nodes upon which the applications are being managed. Once you understand the operation of managing applications on linux, you can do the same operations on Windows or OpenVMS, for instance. With this in mind, the Console is designed for maximum efficiency and understanding and includes these features:

  • Multiple node login capability from one console.
  • Short cut buttons at the top for quick reference and use.
  • Navigation panel to display nodes and components being managed.
  • Content panel provides complete application configuration and status information.
  • Audit function provide history of the process restarts, failures, starts and stops
  • System statistics for each node includes, CPU, memory bar chart, devices, and errors.
  • Operator access to the process table now includes the ability to stop or kill an individual process in case of deadlock or runaways
  • Performance groups can now have actions associated with state changes so that changes in status can be propogated to operations or development.
  • SNMP support for other tools like HP OpenView and BMC Patrol.


The benefits of using a Graphical User Interface (GUI) to monitor and maintain your infrastructure instead of creating scripts is as follows:

  • All Application sub-components are easily displayed in a console window.
  • Infrastructure rules are easy to change in a GUI.
  • Console GUI displays all application statuses in one, easy to understand display.
  • GUIs don’t require operations to learn a scripting language.
  • A GUI console can provide management, monitoring and configuration tools all with the click of a mouse.
  • Focuses interaction with the application performance and application monitoring.
  • A mobile device can display the GUI making management more dynamic.
  • Simple, pro-active health scripts prevent outages, increase performance.
  • Mouse click operations speed up scalability functions with copy and paste.
  • Configuration files capture application infrastructure for easy deployment to additional machines.



The difference in DevOps tools today is usability. Do you want to manage scripts for infrastructure intelligence, or would you rather use a Graphical User Interface? Is it easier to teach operations how to maintain scripts or learn an Operations console? It is faster to capture the developer knowledge in a script or in a configuration file read by a GUI console?

NXTmonitor, which has evolved application performance management for decades, has advanced the creation of this intelligence with a rich GUI console, making it easier to define, modify and monitor application configurations in Development, Test, QA and Production. Once you have the developer knowledge captured in an XML configuration file, you can monitor and maintain it easily in the NXTmonitor Console.

For more information, go to:

eCube Systems Announces DevOps Visual Solution NXTmonitor at DevOps Summit/Cloud Expo in New York

eCube Systems is attending its first DevOps Summit at the Cloud Expo and will give a presentation on NXTmonitor, the APM Visual tool for DevOps.

eCube Systems, a leading provider of middleware modernization, integration, and management solutions, announces the release of NXTmonitor, a full featured Application Performance Management tool with extended capability for DevOps. NXTmonitor, which inherited the code base of NXTminder, has been extended to support multi-discipline processes and will act as a DevOps utility in a heterogeneous enterprise environment. Previously, NXTminder was packaged with NXTera middleware to configure and manage Entera and NXTera RPC servers.

“Since its first incarnation as Netminder, this solution is perfectly adapted to DevOps, but has never been marketed for that capability. In addition to its ability to monitor and resolve application runtime issues, NXTmonitor has the ability to capture application dependencies and infrastructure in a portable configuration file that can be exported from Development to Production,” says Kevin Barnes, President of eCube Systems.

NXTmonitor will provide immediate benefits to operations as a distributed application configuration, deployment, testing, and monitoring tool. It will aid in the migration and deployment of an application throughout its entire life cycle as it progresses from development to testing to production environments.

As a DevOps utility, NXTmonitor can:

• Proactively detect, report and fix problems (whenever possible)
• Notify operations of current application state
• Provide audit logs for problem resolution
• Manage application dependencies
• Monitor application health
• Perform intelligent restarting and capacity planning

To learn more, come see us at SYS-CON’s DevOps Summit at Cloud Expo, on June 7-9, 2016 at the Javits Center in New York City, NY.

About NXTmonitor:

NXTmonitor is a platform-independent process control and application management tool designed to simplify the runtime operation and dependability of web, cloud, and enterprise applications built on distributed processes, services, and scripts.

About eCube Systems

eCube systems offers a family of middleware evolution products and services that maximize return on technology investment by leveraging existing technical equity to meet evolving business needs. Fortune 1000 companies and government agencies turn to eCube Systems to reduce risk, extend ROI, and increase productivity as they consolidate existing capabilities and evolve legacy systems to contemporary SOA platforms.

eCube Systems Extends NXTware Remote Development Platform to Linux

NXTware Remote, a distributed development platform using Eclipse developed for OpenVMS, now works for the Linux platform.

eCube Systems, a leader in legacy systems evolution, today announced the addition of the Linux platform to its NXTware product line, NXTware Remote Server and NXTware Remote Studio.

The products, marketed jointly as NXTware Remote, work together to make it easier for teams of developers to develop code on local workstations running Eclipse — to compile, debug and deploy on a remote OpenVMS or Linux server.

Previously, NXTware Remote development wizards and tools were only available on OpenVMS – taking advantage of a distributed development environment, where they could offload development resources to a workstation. Now with NXTware Remote for Linux, advanced development functions on OpenVMS can now be used for Linux so that developers on both platforms can share the same interface, saving time, reducing costs and speeding development. Customers continue to look for simpler and faster means to develop and deploy applications. The new NXTware Remote suite of tools for Linux servers help customers, who have standardized on Eclipse, to gain the benefits of the distributed development on Windows, linux or Mac.

“Until now, OpenVMS customers migrating to Linux had to train their developers on different skills,” said Kevin Barnes, Professional Services Manager, eCube Systems. “Now with NXTware Remote, OpenVMS and Linux can share the same development platform, saving time, reducing costs and speeding delivery.”

NXTware Remote allows developers to follow their usual Eclipse-based development processes to complete tasks on either OpenVMS or Linux. No changes are required to their routine. Users can quickly, compile, debug and deploy code remotely on OpenVMS from their local workstation, while easily integrating with source code management systems.

The server component of NXTware Remote, NXTware Remote Server, executes all of the operations called from Eclipse and returns results instantaneously. The same technologies that made this distributed environment successful on OpenVMS will enable remote development for Linux. NXTware Remote for Linux supports all its existing functions including remote login, browsing, editing, debugging and advanced developer tools in COBOL, Fortran and C/C++.

About NXTware
NXTware is an Enterprise Evolution technology platform that enables legacy assets to be enhanced, maintained and integrated from within Eclipse. NXTware Enterprise Platform include the NXTware Integrated Maintenance Environment IME, NXTware Server and NXTware Remote. The entire NXTware Enterprise Platform is available for all major operating systems including Unix, Linux, and OpenVMS.
About eCube Systems

eCube Systems offers a family of legacy evolution products and services that maximize return on technology investment by leveraging existing technical equity to meet evolving business needs. Fortune 1000 companies and government agencies turn to eCube Systems to reduce risk, extend ROI, and increase productivity as they consolidate existing capabilities and evolve legacy systems to contemporary SOA platforms, such as ESB and Web Services.

eCube Systems, LLC, is headquartered in Montgomery, Texas, with marketing offices in Boston, MA and R&D in Montreal Canada. For more information, contact eCube Systems by email, on the World Wide Web at or by calling +1-(866) 493-4224.

Flexible IDEs and the Future Success of OpenVMS

In our OpenVMS survey, we asked respondents if they agreed or disagreed with the following statement:

Flexible OpenVMS IDEs will play a major role in the future success of OpenVMS.

The majority agreed with the statement: 77% agree and 23% disagree.


At eCube, we think IDEs are vital to the future success of OpenVMS. NXTware Remote, our Eclipse-based Integrated Development Environment, allows developers to write code on a local workstation and then deploy, compile and debug on any remote server. Developers are more productive (even of they are not familiar with OpenVMS and its infrastructure) and the code quality improves.

What roles do you see for IDE’s in the OpenVMS space? Can a modern integrated development environment make for a more vibrant and successful/productive OpenVMS Community?

We are writing a white paper about the survey results.  Sign up to receive a copy via email.