We are also in the process of adding Snapshot support for the Perl API for build 476. Now you can access historical versions of the code through your scripts as well. For example you can compare versions of files or write a script to compare metrics between versions.

What does this mean to you as an Understand script user?
In addition to the new features, the main side effect might be that some scripts might no longer work.

If any of your scripts stop working, review this list of incompatabilites in the Perl delta document. You can also make sure the scripts are still valid syntax by running maintain_uperl -c myscipt.pl.

The new snapshot changes modify the API in a few different ways:

• Db::snapshots() to get a list of snapshots for the db.
• $snapshot->name() to get the name of a snapshot and
• $snapshot->open() to open the snapshot and return a $db variable that represents the snapshot.
• The $db object is now “live”. It never used to be and it was never important that a script pass around and use the correct object. It is now critical.
• Entity objects carry with them knowledge of the database/snapshot they belong to. Multiple databases/snapshots can be open and you can have entities from them all at once.
• Any scripts which used entity ids $ent->id() as keys in hashes must be updated – the $ent->id is no longer unique across snapshots and multiple databases
  • At the beginning of the script add:   use Tie::RefHash;
  • declare the hash with:  tie my %my_hash, ‘Tie::RefHash’;
  • use the actual entity object as the key $my_hash{$ent}, not the dereference of the entity $my_hash{$ent->id}.
  • Don’t use Understand::ent->new($id) to reconstruct an Ent object from the id.

If you run into any problems that you need help with, feel free to post a question on the scripting forum, or shoot us an email at support@scitools.com

UPDATE- We found some issues with the above approach to $ent->id and changed it with build 477. Using a Tie::RefHash for entities does not work as intended and is no longer recommended. We added a new call $db->ent_from_id($id), to reconstruct entity objects from ids.  To use entities as hash keys without later retrieving the entities from keys, it is sufficient to simply use $ent for the key. To later retrieve an entity from a key, instead, use the entity id as the key ($ent->id()), and retrieve the entity from the key with $db->ent_from_id($key). Note, it is not possible to safely store entities from different db’s into the same hash using this technique, since id’s are not unique across multiple open db’s.

We’ve had dependency analysis in Understand for many years.  With B471 of Understand 2.0 we have consolidated it into a functional area of the tool, improved what it does and also added a few new dependency views.

The Dependency Analysis capability provides these features:

• rapid browsing of dependencies for files and Understand architectures
• Dependents, Depends On, and Butterfly graphs for files and architectures
• Spreadsheet export of dependency relationships
• A new Dependency Browsing dock that shows all depedency information

Read on to learn more about the Dependency Analysis capability and what we plan for it.

Or watch the video here.

Lots of Data

To calculate dependency we have to examine every refererence in an Understand project. We then build up dependency data structures for every file and architecture. This includes the nature of the dependency and the references that caused the depedency.

Because this can be a lot of data, we don’t calculate this as you ask for a given dependency relationship. Instead, we calculate all dependency information, cache it, and this makes subsquent exploration and browsing quick.

So the first step is to tell Understand you want to explore dependency information, by choosing:

Note the Scitools Labs icon next to the menu. This means this is an early feature, so don’t depend on it and also send feedback if you have ideas about it.

Depending on the size of the project building this cache can take a while. On 2 million lines of code, it will take about 15 seconds, but the time will depend on the reference density of the code.

After reparsing the cache will still be used, you currently have to remember to update it, although in a build or two we will ask if you want to update it.

Exploring Dependencies

Once the cache is created, you can now explore dependencies using the Dependency Browser. To get it, right click on a file or an architecture and choose “View Dependencies”

The Dependency Browser then pops up, by default docked to the right side of the interface.

The browser shows that “adler32.c” depends on two other files (zconf.h and zlib.h).  Clicking on zconf.h shows the references that caused the dependence.   It also shows that adler.c is depended on by 3 files, to see them click on the tab.  Note that these references are hot, click on them to visit the source location.

The [x] Sync button at the top tells Understand to show dependency information for whatever entity you click on elsewhere in the interface.

Dependence Graphs

We provide, currently, three graphs for files and architectures:

• Dependency Graph – edges show that node a depends on node b
• Reverse Dependency Graph – edges show that node a is depended on by node b
• ButterFly  – shows dependence and dependency

To get a graph, just right click on the file or node in question, or choose the graph icon in the Dependency Browser:

Choosing the Dependency Graph for adler.c we get:

Adler.c depends on zlib.h twice in the code, and 4 times on zconf.h, and so on.

Data Export

You can export relationship information for a file or architecture to CSV format by clicking on the  icon. This will do output dependency relationships in matrix form for that entity. 

You can also get the matrix for all files or architectures by choosing the CSV export options from the main Dependency menu:

Our Intentions

We want your feedback on these features – both in how we implement them and also what else we should do.

Our plans currently include:

• Dependency information for Java, C#, C++ Classes  & Ada Packages
• Dependency Rules – a specification system indicating permited and non-permitted dependencies
• Dependency Corrections – system for correcting false positives dependencies
• Access to Dependency Information from the C++ and PERL APIs

Customers tell us frequently that they appreciate our weekly builds. They provide a constant stream of new features and bug fixes to Understand users. We like weekly builds because it means we don’t have to provide patch binaries to customers in dire need of an update and also because we hate the idea of a crash or bug existing in the wild longer than necessary.

But what do we do with new capabilities that we want feedback on, but aren’t quite “production ready”? We faced this with Understand 2.0, which had lots of new features/capabilities.  Frankly, I think we took too long getting feedback and had to redo more than we would have liked once we did get user experiences.

Going foward we have big plans for Understand and the core technology it is based on. And so that we can get rapid feedback, we will be exposing features much earlier than we have in the past using a vehicle called “Scitools Labs”.

Scitools Labs isn’t some effort to make us look bigger than we are. We are still the 20 something person company we’ve always been.  Instead, it is our way of asking… “this is where we are heading, what do you think?”.

Build 471, which will be released tomorrow, includes three Scitools Labs features:

• Dependence Analysis, Graphing and metrics for files and architectures
• Stack Analysis specific to Microchip Corporation’s compiler/micro-controllers
• UnderstandYourCode.Com – a website hosting free tools, online analysis and new web oriented features we are putting into Understand.

I’ll write more specifically about each new Scitools Labs technology in blog postings prefixed with “Scitools Labs:“.

And remember, your input is the whole idea, so don’t be shy – let us know what you think.