Administration of a CM tool consumes resources.
Installation, tuning, adjusting scripts, rules and triggers. Keeping the object
base servers going. Distributing the load across servers. Performing upgrades
and timing them with other upgrades. Increasing repository limits as the
project grows. Installation and tuning of the underlying database and
associated infrastructure tools. Dealing with the IT department to provide
adequate hardware resources. Recovering from power outages or invalid user
actions. Backups and the effort to minimize backup time and sizes. The list
goes on

With CM+ these tasks are a thing of the past. CM+ requires
no additional infrastructure. No tuning, scaling, load distribution. No
expensive hardware to work out with your IT department. Backups are simply your
everyday OS backups. Automatic recovery from system outages and easy recovery
from intentional malicious user actions. Easy minimization of backups. No
performance issues. Simple upgrades, independent of other tools. Automatic
repository scaling from 1 user to thousands of users. In short, your CM
administration team should cost you less than an hour a week on average,
including installation and upgrades! Compare that to your current CM admin
costs.

CM+ is very competitively priced, especially when you
consider the list of applications provided versus what you would pay for them
separately. But the cost of licensing is only a small portion of the ownership
costs. Your CM administration costs will tend towards zero. The ease of use
will mean that your CM librarians need far less training, as will your
end-users - that means lower training costs and less productivity loss. The
migration/roll-out process is rapid, not a project unto itself. Upgrades are
painless. Your maintenance fees cover all new upgrades to the product at no
additional cost. You'll have a much smaller need for consulting because most of
the customizations you can do yourself, right from the GUI. And if you do want
to make some major extensions to the tools suite, we'll help you at far below
industry cost, or train you to do it yourself. You won't find a pile of scripts
to maintain with CM+, and you likely won't create many yourself. Typically,
you'll insert a few lines to add a few menu buttons; or perhaps you'll edit a
single line to provide some additional options and specify some more practical
defaults and terminology. Say good-bye to your CM script-building team. Your
infrastructure costs will be low and will remain low. No need for underlying
repository purchases, special reporting tools, etc. No need for additional
hardware as your project grows - a single server can support thousands of
users. Disaster recovery implementation is simple and straightforward using the
Synchronous Multi-site option. Use it to provide a warm stand-by capability for
your server as well. Use Neuma's expertise to be up and running the way you
want, in just a few days! Experience the savings a 3rd generation CM tool
provides.

Ever hear that you can have a tool suite supporting a fully
unified process at a reasonable(?) cost? Except that the process it supports is
not your own. With CM+ we'll start you off with Neuma's Unified Process,
configured to meet your own processes. Your processes add value to your
deliverables. Don't be forced to abandon them. Instead find out how CM+ can
help you streamline and support your processes, providing enforcement where
necessary. CM+ will also help you to evolve your processes quickly because the
high level process engine allows you to incrementally modify your process
instead of taking your resources into a script-writing and debugging exercise.
Neuma's expertise will help you evolve your processes to meet requirements you
may not even have dealt with yet: like dealing with third party software and
their updates; like identifying feature differences between builds; like
providing full change control for your requirements. See the improvements to
your quality certification process as you climb the process maturity
ladder.

CM+ was built from the ground up to be a suite of integrated
tools, but also one that could be easily extended and customized. You'll find
as you add in a new application, the work to integrate it with the other
applications is almost non-existent. The STS engine and GUI generation
capabilities provide a level of integration likely beyond what your
expectations are, virtually for free. CM+ has a process engine for easy
definition and support of your process model. It has a GUI generation facility
to automatically allow data query, form browsing, data relationship navigating,
form generation, Web interface capabilities and more, painlessly. The STS
repository goes far beyond relational capabilities allowing you to express
integration links, data revisioning requirements, hierarchical relationships,
and other complex requirements with a whole lot less effort than you're used
to. Create pop-up dialog panels with the terminology your users require, with
the precise set of information on them, using intelligent defaults - typically
with a single line of code. Add a GUI menu button, with full qualifications of
when it is or isn't displayed, with prompting for required user input, again
typically with a single line code. Neuma's advanced macro and GUI generation
capabilities augment its extensive command language and browser component
library to simplify your work. Instead of you and your team working for the
application, make the application work for you!

CM+ was designed for mission critical applications, with a
special focus on the telecom and aerospace sectors. Many features can be found
in CM+ that simply don't exist elsewhere. Users can continue to do most of
their work, even if the server machine dies - in fact, most users are unaware
of server outages before the outage is resolved. This is due to the smart
client architecture which permits an extensive query capability, even in the
absence of the server. The server automatically recovers from outages such as
power failures, system crashes, regular re-boots, etc. And Neuma provides a
number of services in CM+ such as single file checkpointing and checkpoint
recovery to permit the repository to return to its state at a precise point in
time. Large object mirroring at the application level permits mirroring of some
important data without the need for full disk mirroring, and with substantially
more flexibility. Warm stand-by and remote disaster recovery capabilities are
easily implemented using the Synchronous Multi-site capabilities of CM+. End
user reboots are protected by an automatic transaction recovery feature.
Restore capabilities helps protect against malicious actions, with full
recovery from a diagnosed problem typically in minutes. Neuma is serious about
your data - that's why we take care of it.

Neuma's full transaction journalling capability helps you to
identify exactly who updated the repository at what times, with what actions.
But CM+ goes further. If you have a need, for whatever reason, to roll the
system back to an earlier point in time and then roll forward using edited
transactions, CM+ can do that for you. If you need to search transactions for
specific changes or specific pieces of data, CM+ can do that for you. And the
easy checkpointing facility allows you to regularly checkpoint your repository
in a few seconds, automatically or manually. Futhermore, the checkpointed
environments may be viewed using the normal CM+ interface so that you may fully
inspect the state of the checkpoint before using it, should the need arise. And
if you erroneously resort to an old checkpoint, it is just as easy to move back
to the future using any of the checkpoints automatically maintained by CM+ as
part of normal operation. The layered data granularily permits the state of
your repository to be captured at various levels. The read-only migration
capability allows you to run with most of your data secure on read-only media
from which it is automatically migrated when the need to update it occurs. Your
repository and transaction journal can reside on separate disks so that full
recovery from a disk crash is quickly and easily accomplished, without the need
to go to off-line backup data. You won't need to use these facilities much, but
it is good to know that they're there and that they've been well verified. It's
not just your data, it's our reputation - Neuma treats your data with
respect.

Late in the 1990s and early in the new millenium, the CM
community began a revolution. It began to look at changes in a new light.
You'll see tools from the various vendors sporting capabilities to package
changes and even separate them into appropriate development streams. Though
this effort is in its infancy, Neuma and its development team members have been
doing this for over a quarter of a century. So it's natural that Neuma is way
ahead of the game. The kinks have been ironed out years ago, but Neuma
continues to advance its world-leading CM maturity. Change packages are not
just a way of packaging files which logically belong together in a change, they
encapsulate the central concepts and data relevant to a well engineered change
control process. Integration data, traceability information, file changes,
directory structure changes, test information, compatibility information and
other data allow you to use CM+ to control change carefully. Whether it is
putting restrictions on a development stream which has gone into field testing,
allowing you to back out changes that cause build problems, building a new
release by selecting the problems you need fixed in it, or comparing builds to
identify the files, developers, reasons, features or code changes differing
between them. CM+ is way ahead of the game. Parallel stream management isn't
just a case of labelling branches and allowing merges. On the contrary, CM+
dramatically reduces the need for merges and eliminates the task of branch
labelling, and the associated headaches. But CM+ also allows requirements,
activities/features, problems/issues/defects, changes, builds, releases, test
suites, documentation, etc. to evolve independently in multiple streams, while
at the same time minimizing copying and merging by sharing objects among
streams across which the objects have no differences. This is further supported
with our best practices through sharing across products and even the sharing of
products in a product/sub-product hierarchy. No, you won't need all of this
today, but it is easier to use and you won't have to switch tools in the future
when the need arises but the schedules and budget restrict.

The CM industry largely relies on branching and labelling
strategies to provide support of parallel development streams, grouping of
files into changes, definitions of patches, etc. It is a complex situation
which requires adequate fore-thought so that the strategies don't wear thin as
the product and delivery requirements grow. Yet even with the best thought out
strategies, there are a myriad of complexities - how to minimize merge
requirements, how to collect changes for a patch release or custom build, how
to recognize the correct view for addressing a problem in the software. Neuma
took a different approach in developing CM+. Change packages were not an
add-on, nor were mechanisms to deal with custom builds, patches, context views,
etc. Neuma addressed these problems head on. It established an appropriate
framework so that CM+, rather than the developer, could decide if branching is
required. Its architectural design ensured that objects would not be branched
until such time as two separate versions needed continual support. It
introduced the concept of build records, not simply to identify what went into
a build, but as a mechanism to track custom builds, patches to builds and to
provide a means to easily view the software and related information from the
perspective of the build. Neuma looked from the product management level at the
need for parallel development and support and introduced streams to handle
these requirements. In the end, Neuma completely eliminated the need for
labelling strategies and resolution of the strategies when baselines are
merged. It eliminated the need for developers to learn a new language or
mechanism for working with different versions of the software. Instead, a
developer simply chooses to work on a particular release or stream of a
product, or against a particular build record. In more demanding cases the
developer tailors the environment based on the promotion/test level required,
adding, if necessary, particular changes-in-progress to the pre-selected
environment. It doesn't matter if it is an old release or a future release, CM+
works the same. But somehow the overhead is gone. The delays between freezing
one release and starting another is gone. In fact the whole process of starting
a new release stream is as simple as defining the name of the stream (e.g.
rel5), typically done at the start of requirements gathering. There's no need
to keep changes out of the CM system until the CM manager opens the floodgates.
Changes can safely be checked into CM+ years in advance without affecting
existing development and support streams, and allowing a more incremental
approach to future changes.

Neuma designed CM+ to be portable. From the start, a
portability layer was introduced into the architecture. As a result, releases
are generally available at the same time on all platforms, and can be very
rapidly ported to new platforms. With few exceptions, users work the same way
on whatever platform they want. Neuma has gone a few steps further though.
Moving a CM solution from a Unix architecture to a Windows architecture is a
trivial exercise: shutdown the server processes and restart them on the new
architecture, optionally moving the repository through a simple directory tree
copy or move operation. Move it back just as easily, in minutes. The client
side is even easier, simply move to the platform you want and start using CM+.
The interface is very similar, the functionality is the same - ok, maybe you'll
want to configure your default editors to your preferences on the new platform
- but that's a single step through your Edit/Preferences menu. In fact, the
client can continue to work on both platforms, simultaneously. There are no
conversions that need to be run, no new special rules or instructions. Just
move and go, when it suits you. You don't have to re-do your management tool
integration because CM+ is your management tool suite. Beginning with release
6.0, the process is identically easy for moving between a 32-bit and 64-bit
architecture. Move back and forth or work on both. The CM+ architecture was
engineered to rise above the platform wars. In fact, today's deliverables
continue to run on 10+ year old platforms. And deliverables from 10+ years ago
continue to run on upward compatible platforms including Windows, Linus,
Solaris, HP-Risc and others. Neuma raises the bar for platform
inter-operability.

Whether you're just starting to build your product
management suite or upgrading from your existing solution, you could have a lot
of work ahead of you. You have to evaluate each of the tools, find out which
ones work together, see how well they work together, understand the work
required to integrate them, put a team together to do the integration, deal
with multiple vendors, customize each tool, schedule training for each of the
tools, and so on. However, if you choose CM+ to start, the end is already in
site. A single tool, a single vendor, easy customization, dramatically less
training, no integration work. Yet you come out on top, with the most mature
configuration management, the most mature process management, easy
customization of your data, process and user interface requirements, a level of
integration far beyond your dreams, and no team required to do the roll-out. No
timing considerations based on different tools and their timeframes for new
releases. CM+ provides an end-to-end suite of product management applications:
Configuration Management, Change and Version Control, Document Management,
Problem Tracking, Project/Activity Management, Test Suite Management,
Requirements Management, whatever else you need. Neuma can extend the
application set to meet your needs, or let us show you how to do it easily
yourself. Imagine having a suite of mangement tools which communicate the
information you decide that you require, in the same way across applications,
with little training. Customize a single button, a dialog panel, a form, your
data, your defaults, your workflow, your rules, your reports. Easily. And don't
worry about timing upgrades. Don't worry about when you'll outgrow the tool.
Don't worry about ever buying another tool for your suite. How suite it is!

As a 3rd generation tool, CM+ has already opened up a new
level of interactive query and data navigation, a new level of performance and
speed, a new level of process engineering. As CM+ prepares to launch its 4th
generation CM tool in 2004, the gap between CM+ and the closest competition
will widen. Neuma engineered CM+ so that you can point-and-click to get
results. Don't write a report to compare two builds only to wait for it to run
and then to find out that it wasn't quite the one you meant. Point-and-click on
the Compare Builds menu of CM+. Select Problems and a list of problems resolved
quickly pops ups. Select Developers to instantly identify who worked on the new
build functionality. Select Requirements to identify which requirements were
addressed. Select Files to see which files were modified. Select Code Changes
to see the actual code differences. The integration of the information which
permits these actions is one thing, but the speed at which you get the results
permits a whole new way of working. Don't generate reports for a meeting. Look
at them in real time, and zoom in on the results. Produce data summaries in
tabular or graphical format that show you the state and priority of
problems/issues for your current development effort. Then zoom in on the
appropriate graph bar or table count with a single click of the button. Zoom in
again to a particular problem and all of its details - change the details right
there if necessary. Use a form browser to specify an arbitrary set of records
to scroll through, form by form. No delays - scroll through them as fast as you
wish. Use the tree browsers to look at hierarchical data: browse through the
staff list and peek at ToDo lists for various staff members; browse through
your product source code for the file that needs fixing in the current
development stream or in a previously defined build or release; select a
project and browse through the WBS (work breakdown structure) for it; browse
through your hierarchical document library, or perhaps your requirements tree.
Look at the history of a file, or the development history of a user. And when
our 4th generation release is ready, you'll do a lot more, easily, naturally -
because you've customized it from the out of the box process to work the way
you want and to show the information you want, for project managers, for
developers, for testers, for product managers. And then ask yourself - why
doesn't this slow down as our repository grows in size? How can I search
through the abstracts of thousands of documents or the descriptions of tens of
thousands of problem reports at such speeds? We're not telling our secrets, but
we'll let you experience them, today.

Even though you'll rely heavily on the interactive query
capabilities of CM+, you'll still need a powerful reporting capability. Perhaps
it is to communicate to your customers what's in the upcoming release. Maybe it
is visual quality or progress trends that help you understand how close you are
to a product release date. Or perhaps it's a number of metrics required by your
management team. CM+ provides the flexibility to produce the report you need.
Pre-canned reports are available, or you may create custom reports using the
Custom Report panel, and save them for reuse later. You can export your data to
a spreadsheet for maximum flexibility. Sort it, total it, define what you want
in your current development stream or across streams. For a particular product
or across products. Pump it out in text format, in HTML, in XML. As a graph, as
a table, in a Gantt chart. Even print out your workflow diagrams for those
quality improvement sessions. Report against a particular subsystem or against
a portion of the org chart. Use recent data or the entire data history of your
project. And if you need to add new data from on old tool or from an acquired
company, CM+ can import it easily, as long as you can get the information out
of your old tool, CM+ can get it in quickly, without having to write a new
program to do so.