About International Software Automation, Inc. (ISA)
International Software Automation, Inc. (ISA), founded in 1992 and located
in Sam Mateo, California, USA, is a world leader in software
automation. As its name suggests, ISA develops technologies
and markets products for automating software engineering.
In the past few decades, the software engineering industry has
contributed greatly to full automation of engineering
and manufacturing processes for many other industries. But unfortunately,
the baker is still hungry himself -- most processes of software engineering
are still being done manually. It is time we the software engineers
should realize automation for our own industry!
ISA sells what it uses itself. There is a story behind the automation
techniques and tools developed by ISA.
Years ago, the founder of ISA established a CAD company
to develop and market VLSI placement and
routing system for the design of very large and complex VLSI chips.
After a prototype has been built, the development team realized that
it would be impossible for them to complete the final system on time.
Too much time and effort were spent on trying to understand the system
developed by separate groups, drawing and modifying design diagrams,
finding out whether a function or a code branch has been executed,
and measuring the quality of the system.
Sounds familiar? The development team realized that they need a set of good
software engineering tools for diagramming, testing, and maintenance. But
after an exhaustive search, they found few useful tools.
For example, most of the software diagramming
tools available were inefficient semi-automatic graphic
editors. Although some tools could generate overview
diagrams from source code, the poor layout made the digrams confusing
rather than helpful: for example,
a caller and its callee were often placed on the same row making it hard
to see the calling relationship, connecting line would pass through other
function boxes, making them unreadable.
The control flow diagrams generated by the tools were also
hard to decipher since they were not structured.
Furthermore, the team found that there is no difference in the
representation of different program logic, no information about
the logic location of the source code or the logic execution conditions, etc..
In addition, almost all diagrams generated by those tools were static:
there is no linkage between different diagrams or different levels --
from the overview to the control flow diagrams.
The test coverage analysis tools available provided only generic statement
test coverage, or very rough branch coverage. It is also hard to determine
where exactly are the untested code. The coverage results were hard
to see since they were shown in textual format with source list.
Frustrated by what they found, the young CAD company decided to develop its
own set of software development tools.
Because the tools were designed to aid in the
development a huge and complex VLSI layout system capable of
handling more than one million components, the requirements
for those tools were comprehensive and rigorous. They include
With years of effort, those tools were developed and integrated into a software
engineering environment. It automates many tasks, facilitates software design,
coding, testing, and quality measurement -- thus greatly raises productivity of
software development for the entire company.
Reaping the benefits of using the environment, the founder realizes that the environment
can be useful for any software programmers and software developers.
Of course, the market for those tools could be broader than the market of the VLSI
- no size limitation on the program to be analyzed and diagrammed;
- using advanced algorithms for VLSI layout
in the layout of the overview diagrams -- for example, in the
function call graph a caller is placed higher than the callee
(except for recursive calls)
and that no connection line passes through any function box;
- creating and using structural diagrams for representing program
logic and control flow; using different notations to represent
different program logic; the generated control flow must be shown with
the information about the logic location in the source code, and
logic execution conditions;
- allowing users to use popular programming language such as C or C++
to specify system design for automatically
generating high-level design diagrams directly from the system
specification files; able to assign
bottom-up coding order to all functions on a generated function
call graph, and allowing users to use a module editor to directly
edit each function (by following the coding order) to extend the
system design specification files to final source code;
allowing users to use the final source code
as the extended system specification files to update the design
diagrams (it means that the design of the system becomes
pre-coding, the coding of the system becomes further design of
the system. Since the design diagrams and the executable program
come from the same source files, this ensures consistency
and facilitates maintenance);
- generating all diagrams automatically, including function call
graph, program hierarchy tree, data structure diagram, function
logic diagrams, and control flow diagrams;
- automatically linking all diagrams at different levels together and
making the diagrammed code traceable at all levels through a
click-to-jump facility from a function
node at the
system hierarchy tree to the low-level diagram of the function
body, from a "#include" statement to the body of the included
header file, from a function call statement to the called function
body, from a goto statement to the corresponding label, or from a
function box on the generated call graph to the logic diagram /
control flow diagram of the function, etc.;
- generating all diagrams and analysis reports selected dynamically
and quickly rather than storing the entire set of diagrams on disk,
thus saves disk space;
- making the diagrams generated highlightable, e.g. highlighting
a module path or a logic path so that the users can use a
generated diagram itself as an interface to operate it;
- allowing the related data obtained from static and dynamic analysis
of the code be shown with the diagrams generated, such as the
complexity and the test coverage;
- automatically highlighting all code branch / segment and condition
outcomes unexecuted in the generated logic diagrams and control
- allowing users to operate several tools at the same time to
display of related objects / modules, such as that the user can
select a requirement specification or a test case used with the
the requirement (shown in blue) to highlight all the functions
the requirement or tested by the test case on a call graph (in
program scope), and
all related or tested class / function (in file scope) on a
file-class-function diagram, also the all related / tested code
segments on a control flow diagram (shown in red), etc.;
- performing code instrumentation and test coverage analysis of
class/function/block/branch/segment/condition outcome (predicate)
automatically from users' original Makefile files or batch files
without the users to modify them or create input-bin file to
manually list files to be analyzed;
- showing the test coverage results graphically with capability to
highlight unexecuted code branches and condition outcomes;
- measuring the quality of a program automatically;
- generating various analysis reports from static analysis and
dynamic analysis of code, and making the reports on-line accessible...
Finally, the founder decided to make the software environment available to all
developers. Thus ISA came into being.
Panorama C/C++ starts a new generation of the software engineering environment
with enhancement for the support of Object-Oriented software development,
testing, quality assurance, and maintenance.