Overview | Pricing & Licensing | Evals & Downloads | Compatibility | Publisher Details | Reviews | Support Forum | Summary

Our regular prices are shown below. Please logon to see your discounted prices.

MaintainJ 4.0.0

Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase.  All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed, including volume licensing and previous versions.

Our regular prices are shown above. Please logon to see your discounted prices.

What's New in MaintainJ 4.0.0
This release adds the response time tuning capability in a single user environment.

• Response Time View - The sequence diagram and the corresponding 'Outline view' are redesigned to allow the user to quickly find the methods that are taking the maximum response time in a use case.
• Filter Calls by Response Time - This feature allows the user to filter out all the calls whose response time is less than the specified time.
• Delete All Classes Except - This feature can be used to quickly see the interactions between the important classes in the use case.
• Shows the number of times a method is called in a loop - MaintainJ always removed the loop and recursive calls to avoid cluttered sequence diagrams. This version adds the feature to show the number of times a method is called in a loop.
• Opening trace files generated using older versions - To open the trace files generated using the older versions of MaintainJ, copy them to the 'MaintainJ Trace Files Project' created using this release. This project can be created by following File->New->Project->MaintainJ->MaintainJ Trace Files Project. Please note that the trace files from older verisons do not have information about the number of times a method is called in a loop.

Reverse Engineer Java Like Never Before
MaintainJ is the tool to turn to when you want to:

• Find out what exactly happens when you run a use case
• Generate interactive sequence diagram from call trace
• Reduce the bug fix and release cycle time of your applications
• Document your applications in minutes

The following are the three steps you need to do to generate diagrams:

Step 1 - Instrument Code
This step changes class files at runtime. No changes are done to the source files nor are any changes persisted to the file system. You can choose the packages to be instrumented. Instrumented applications are slow to service for the first request but perform with little overhead later on.

Below are the types of Java applications supported out of the box by MaintainJ.

a) J2SE applications/Applets/JUnit - Tracing J2SE applications (Swing or non-GUI), Applets and JUnit is supported.

b) J2EE applications - The following J2EE application server are supported - Tomcat 4, 5, 6 and 7, JBoss 3, 4 and 5, WebLogic 8, 9 and 10, WebSphere 5, 6 and 7. Glassfish and Jetty servers are also supported. If your server is not supported straight away then you can manually configure MaintainJ to work for your environment.

c) Databases - MaintainJ captures the actual runtime sql calls sent to the database regardless of the JDBC frameworks used by the application. MaintainJ supports Oracle, DB2, MySQL, PostgreSQL and Derby out of the box. Microsoft SQL Server also is supported. Contact support if you are using MS SQL Server or any other databases.

Step 2 - Generate Trace Files
Next, run the instrumented application and demarcate the start and end points of a use case. Call trace for the use case will be logged to the given trace file (.ser file).

a) J2EE Applications - A JSP is provided to demarcate the start and end points. You need to click a 'Start Tracing' button before a use case starts and click 'Stop Tracing' at the end of the use case. The call trace will be logged to the given file when 'Stop Tracing' is clicked.

b) J2SE/Applet/JUnit - A Swing window in which you can start and stop tracing opens when your instrumented application starts. Click 'Start Tracing' button before a use case starts and 'Stop Tracing' at the end of the use case. The call trace will be logged to the given file when 'Stop Tracing' is clicked.

Step 3 - View the Diagrams
Create a MaintainJ Trace Files Project by following File->New->Project->MaintainJ->MaintainJ Trace Files Project. Copy the trace files to this project and open to view the diagrams in the MaintainJ UML Editor.

MaintainJ UML Diagram Editor
MaintainJ UML Diagram Editor renders sequence and class diagrams from the call trace files. To view the UML diagrams, add the trace files to a MaintainJ Trace Files Project in Eclipse and open. MaintainJ Trace Files Project can be created by by following File->New->Project->MaintainJ->MaintainJ Trace Files Project.

All menu options in MaintainJ UML Diagram Editor are provided in context menus, which can be seen by right clicking anywhere in the diagram or the Eclipse Outline View. Depending on the selected figure, relevant options are displayed in the context menu. You can 'Undo' and 'Redo' most of the operations in the editor.

Areas where MaintainJ can help developers:

• Dynamic Binding - Dynamic or runtime binding in Java makes understanding code more difficult. Developers often need to understand the runtime object interactions for a specific use case either to debug or enhance the application. Dynamic binding helps in building very flexible systems but, at the same time it increases the time to understand the system. It is also common to employ multiple levels of dynamic binding, like a Vector containing another Vector, which further complicates the issue.
• Observer Pattern - Many enterprise applications follow Observer Pattern for flexibility, where 'listener' (or observer) objects change model state besides 'listening' (or observing) for the state changes. When many such listener objects, which are often determined at runtime, change the model, it becomes hard to understand and debug a large application.
• Multi-threaded Applications - Multi-threaded applications are always difficult to code and debug. Using MaintainJ, you can see the sequence of method calls happening in each thread in a neat sequence diagram. This makes debugging multi-threaded applications much easier.
• Externalized Data and Rules - Externalizing configuration data as well as rule based logic to XML files is commonly found in present day Java applications. Very often, the logic to determine the runtime classes is soft-coded in xml files. In a poorly documented large-scale system, it is very hard to understand how the xml file drives the system.
• Poor Design - Designing robust and flexible systems at the same time is hard. Maintaining them as the systems evolve is harder. If poor design slips into this equation, it becomes extremley hard to understand a system after 2-3 years from initial launch.
• Complements Debugger - MaintainJ complements debugger rather than replacing it. By generating the class and sequence diagrams for a use case, it reduces the time spent in debugger. Unlike other reverse engineering tools, MaintainJ offers uncluttered and focused UML diagrams. For sequence diagrams, which get cluttered very easily, MaintainJ offers features like call folding to generate crisp diagrams.
• During Code reviews - MaintainJ can also be used during code reviews. Rather than reviewing the entire source code, you can review the diagrams to find deviations from the design standards. Class diagrams showing the dependencies help to weed out unwanted dependencies.
• For Agile Teams - For agile programming teams, MaintainJ provides always up-to-date documentation of the system. Useful UML diagrams can be generated whenever you need them.