Debug, Enhance, Tune and Document in just a few minutes


Our Clients

  • ibm
  • ge
  • disney
  • hp
  • emc
  • aig
  • vmware
  • cisco
  • verizon
  • wells
  • fiserve
  • fed
  • usarmy
  • canada


Learn what MaintainJ can do for you

Debug large applications in minutes using runtime analysis

Most defects, even in very large application, are local to just one or two components. Once you identify where the defect is, it is easy to fix the defect. Often, it takes several days to find where the defect is. MaintainJ reduces this time to just a few minutes.

MaintainJ captures the runtime information while you run a use case. The runtime information captured includes the following:

  • Concrete classes and methods called in the use case
  • Parameters passed to each method, the return value and state of the called object
  • The actual runtime SQL statements executed, regardless of the database frameworks used
  • The response time of each method call

The above information is presented as easy to read sequence diagrams. These diagrams can be searched using class or method names or the parameter data. The SQL statements can also be searched by providing the table names or the runtime parameters passed. This capability allows developers to quickly find what they need while debugging. The response time captured can also be used to identify the most important call flows in the use case.

The demo below applies MaintainJ on a very large 8000 class Java application that uses many Java frameworks. Check how we can debug such a large application within a minute.


Enhance easily by understanding similar existing features

Some enhancements involve changing existing classes to add additional functionality. The biggest challenge to complete this task in a large application is identifying the classes to enhance. Once the classes to enhance are identified using MaintainJ, enhancing them is easy.

Other enhancements involve adding a new feature, which is often similar to an existing feature in the application. Once you identify the components involved in the existing feature, building a new feature is a simple matter of imitating the existing feature.

MaintainJ simplifies this process by enabling the developers to quickly find the components to enhance or to find the components involved in a similar feature. Watch the demo below to understand what we mean.


Tune your applications to run faster

There are a few options to make a use case run faster.

  • To find the method calls that are taking the longest time and optimizing them.
  • To find the method calls that are called lot of times in a use case and optimizing them.
  • To check if there is a scope to cache some data instead of repeatedly retrieving the same from database.

MaintainJ captures the response time of each call in a use case. It provides easy ways to identify the potential methods to optimize for the options listed above. Other performance tuning tools might claim to do this as well. But no other tool in the market gives you the insight into how a use case works at runtime like MaintainJ does. Understanding the runtime behaviour of a use case helps you to optimize it much quicker.


Document like never before

MaintainJ generates the UML class and sequence diagrams at runtime while you run a use case. Hence, the generated diagrams represent the truth, not the developer's interpretation of the truth, which is what happens when one manually draws the diagrams. MaintainJ's diagrams show the runtime parameter data and runtime SQL statements. MaintainJ's diagrams also display the response time of every method call.

All this runtime data provides greater information to anyone reading the diagrams. Most importantly, MaintainJ can generate the diagrams on demand in less than 2 minutes; not in 2 days, which is usually the time taken to manually draw the diagrams.