Abstract:

Recent studies have repeatedly found that smaller modules are proportionally more defect-prone. In this article, the authors formulate and test a hypothesis stating that smaller modules are proportionally more coupled, given that dependencies caused by coupling have been consistently associated with defect-proneness. Strong evidence supports this hypothesis. Furthermore, refactoring exacerbates this effect. On the basis of this study’s highly consistent results, the authors state the empirically based theory of relative dependency. That is, in large-scale software systems, smaller modules will be proportionally more dependent compared to larger ones. These findings have two implications for practice. First, we now have an empirically supported mechanism explaining the observations that defect concentration is higher in smaller modules. Practitioners can use this mechanism as evidence while seeking resources and support to revise or amend their organizations’ quality assurance and quality control practices. Second, particularly for the projects that refactor extensively, such as those using agile methods, focusing defect detection activities on smaller modules will increase their efficiency and effectiveness even more.

They used Understand to generate the C++ measurements of many large open source projects.  We donate licenses of Understand to worthy research projects frequently. We’ve e-mailed many times with Dr. Koru to support his efforts and are pleased his work was accepted by IEEE.

The team extensively used the DIT (Depth Inheritance Tree) and CBO (Coupling Between Objects) that Understand provides.

We’ve noted a few ideas for product enhancements from reading their article.

You will notice, however, that the Support Forum hasn’t been moved.  We’ve had trouble with it and our searching for a replacement.

It will come back on line, but not until we have a replacement we think we can stick with long term.

For now, use support@scitools.com or the Chat available on the website for support.

This weekend we released Understand 2.5 (build 507).  Its main changes include:

• Instant Search – a new feature which permits instant searching in even the largest bodies of code. Indexing starts after parsing ends. It operates in the background without holding up any other activities. When complete the search box in the upper right instantly answers your queries.
• Dependency Graphs -  these replace our old dependency graphs with new layout, saving, and cool clustering, save, undo, and redo options. They use a much updated layout engine, which we will roll into our other graphs and use to create new ones in the coming months.
• Simplified Licensing – Understand 2.5 includes all languages and all features. The only licensing difference, in terms of price, is the use of floating or specific developer licenses.  Understand 2.5 does use a new license – your old one will not run it permanently. Instead, it will operate for 30 days, giving you time to request a replacement license if you are under maintenance. This is done directly from Understand or via our website.
• Pricing -  we’ve removed all levels and language variants. Understand 2.5 has it all. This will be our path going forward with new features as well.  The new price is a little higher and the only differentiation is if you need a Single Developer or Floating License.   If you are under maintenance you can update to Understand 2.5 without any cost. Nor will the higher price affect your maintenance going forward. It will remain 18% of your purchase price annually.
• TrackBack Removed – this will be missed by many users, but we needed to focus on core analysis capabilities.
  Take heart, the engineer who wrote much of it will be taking it open source very soon. Look for an announcement here. To be notified by e-mail send a request to support@scitools.com.
• Menu Revamping – menus were moved about and standardized to be more in common with most applications. Additionally, edit menu items are now contextual with editor and graph operations. As an application ages, menus become complex and suffer from bloat. We wanted to simplify and reduce clutter.
• License Manager GUI with Improved Diagnostics – our old license manager does not need to be updated. If it is updated, or for new installations, a new License Manager GUI simplifies operation. Additionally, the server and clients have many more diagnostics embedded to diagnose any licensing manager problems.
• And many hundreds of bug fixes and minor improvements.

We know change can make winners and losers. We’ve tried to make every user a winner with Understand 2.5. If we failed for you, let us know how, and we will try to sort it out and make you as happy as we can.

I have written a .NET sdk wrapper around the understand API during the early spring and last fall. I wrote it because I didn’t want to use Perl anymore, and I wanted the strong type safety of .NET along with it’s wonderful debugging tools.
The API is written in managed C++ (i.e. C++/CLI), and once compiled, can be accessed by any programming language that targets the .NET framework.

More details at http://www.scitools.com/support/forum/viewtopic.php?p=5550

Thanks, Chris!

This is easy to do, and you can create your own User Tools to do many different things.

I went and bundled some CVS commands into a User Tool. Just import it via the Tools | Configure User Tools | Import button.

Download CVS User Tool

I haven’t used CVS in years, so let me know if I got anything wrong

For Input you can chose to use the selected text, the text of the entire current file, or not to use any input. You can output your results into the command output window like previous versions allowed, discard it, copy it to the clipboard, or overwrite the current selected text or file.

For example, the following would replace the word int with float in the currently highlighted text:

Yes, Find & Replace would do the same thing, it’s just an example

An example of replacing an entire file would be when using astyle to format your code. In that blog posting we had to overwrite the current file, and then reload it. Now we can feed the file text straight into the command and then the editor contents get automatically overwritten. No need to confirm the file reload every time:

As with many new Understand features, this was requested by a cutomer, we thought it was a good idea and that other people would use it, so we implemented it. If you have a good idea don’t hesitate to let us know. Just drop us an email at support@scitools.com

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.

Build 470, released today, introduces beta support for VHDL.  E-mail support@scitools.com for instructions on how to enabble that support.

On Linux and the Mac it is quite common to have command line GDB session in use for debugging and to need to inspect or walk a call stack from the “where” command.  It is a bit of a pain to have these separated from Understand. And we may (if we can figure out the Windows side) add debugging support directly into Understand, but until here is a tip that makes working with GDB a bit easier.

With B465 you paste any text into a command result window (get one by choosing “Options->Run a command”).  Once pasted, we analyze it for file, line and entity names and it becomes clickable for Understand events and menus.

Here is a GDB call stack pasted in:

Files and lines are identified so I can visit them in Understand, or right click and get information and graphs.

Also, with B465 we have made file detection much smarter. It will recognize short, relative and full path names and associate line numbers with them in any fashion a compiler or other tool can think to spit them out.

So I’m quite happy to report that Understand 2.0 Build 466 has searching in graphs. To search in a graph just hit the binocular button and enter in the search text. It is incremental. As you type, it matches. Hit return to move to the next, or use the green arrows. The graph will center to the next match. Searches will find on node labels and edge labels (if the graph has them).

Here I search a large call tree for “inflate”:

So you can quickly turn this:

Into this:

We plan on implementing astyle into the editor at some point in the future, but I’m not so patient, and I decided to use our plugin mechanism to do it now, and will show you how.

There are two ways to run astyle from inside Understand, as an Interactive Report plugin, or as a custom user tool. Either way, first you’ll need to install or build astyle you can download it from here.

Interactive Report

The Interactive report integrates directly with the file context menu in Understand. Download the plugin from here(right click and save as). To install it, just drag the file into Understand, it should install automatically.
To run the plugin, right click on a File, select Interactive Reports and Beautify

At which point you’ll be presented with the options window:

The first field is pretty straight forward, just navigate to where the astyle executable is installed.

The rest of the dialog may seem overwhelming, but the tricky part is figuring out what your “style” is. Astyle has 5 predefined styles, and chances are that one of them will be pretty close to what you like.

Astyle’s documentation goes into more detail about each of these styles, but here is a rough overview:

namespace foospace
{
int Foo()
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
}

namespace foospace
{
int Foo()
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
}

namespace foospace {
int Foo() {
if (isBar) {
bar();
return 1;
} else
return 0;
}
}

namespace foospace
{
int Foo()
{
if (isBar) {
bar();
return 1;
} else
return 0;
}
}

class foospace {
int Foo() {
if (isBar) {
bar();
return 1;
} else
return 0;
}
}

If one of these appeals to you as is, just select it from the “Predefined Style” section. If you want to modify one, select it and the other options in the dialog will allow you to override the default settings for a style. For more details about what the command does, select “Display the help text” in the Action section:

When you are ready to run it, you can either preview the changes in a separate window, or apply them directly to the source code. Of course I would suggest previewing the changes until you figure out exactly what your style is. Note that if your project uses relative paths or named roots, only the preview will work right now since the file naming is different, but you can still copy and paste

User Tool

If you already know what astyle command line options you want to use, you can setup a user tool  to quickly transform a file. Again, this only works for projects with absolute paths.

So here are the command line options I want to use with astyle:

astyle –style=ansi -t -B -w -n "C:\temp\foo.cpp""

To implement these as a user tool, I select Tools | Configure User Tools

Then I create a new tool. I name it and provide the path to the astyle executable. Then I provide the parameters, replacing the file name with the $CurFile macro. The lipstick icon is optional For now I decided to show the output in case there are any errors, but you can uncheck that box if you like.

I also decided to bind this to a keyboard shortcut (Ctrl Shift B). You can set the keyboard shortcuts in Tool | Options | Key Bindings.

Now if I run into an ugly file, I can just hit Ctrl Shift B, it will prompt me to reload the modified file..

And bam, pretty code!

• quite low unit pricing
• easy availability of Understand to when engineers move in and out of projects
• much easier licensing (no license manager, it just works on your IP ranges or domains)

If your site might be interested just contact Sue or Kevin at sales@scitools.com to learn cost and technical options.

Here is one of our own source code showing the top 50 most complex functions in source tree.

We thought doing Classes by lines of code, Classes by Sum Complexity and Architectures by the same might also be interesting.

Q: Worth adding to Understand?

BTW: The Cloud was generated by Wordle.net.  We wrote a script that generates output that can be pasted into its text box.   I’ve attached it in case you want to try it on your own code.
File Attachment: wordart.pl.zip

  61 lines of code, pretty small, keeping functionality nice and modular. Good.

  Cyclomatic complexity of 30. Highly complex, but within the acceptable range. Good.

  CountPath metric 536,870,912. What is this? 536 Million paths in 61 lines of code, that can’t be right, can it?!?

The CountPath metric counts the number of unique paths though a body of code. It’s pretty common to have a huge count path metric, even in a small body of code.

In this example, I pull up the code and it looks like this:

29 IF statements in a row. That’s all, logically quite simple code:

But the fun thing about IF statements, is every one doubles the number of potential paths in your code(2ⁿ) – and as we all remember from our algebra days, exponential growth happens very fast.

So 2 IF statements makes 4 paths. 2³ is 8 paths. let me demonstrate:

So for the 3 IF statements here, n=3 and 2ⁿ= 8 possible paths:

ACE
ACF
ADE
ADF
BCE
BCF
BDE
BDF

And any guesses what 2²⁹ is? Yep, 29 IF statements make 536,870,912 paths. Because this metric can grow so large, we do truncate it at 1 Trillion, actually 999,999,999. If we see that many paths, we give up and stop counting. I don’t envy the QA team if they have to test every possible permutation of this, but at least you can believe Understand when it tells you that there are that many paths

Scheduled Activity

The quickest way to automatically get metrics is as a scheduled activity. For example I could setup Understand so that every Friday night it reparses my project and generates the current metrics. I can set it up to save the metrics as a comma delimited file and/or as an html report. This is all configured from Tools | Scheduled Activities.

Command Line

Another way to automate the metrics is using the command line tool und. For a list of the commands available from und, simply run und –help. For more advanced help on a specific command, run und –help command. For example run –help rescan will show the advanced help for the rescan command.

It most cases the first thing you’ll want to do is update your project by rescanning and analyzing. This can be done with:

und –db c:\project\pixie.udb –rescan – analyzeAll

Und lets you dynamically specify the parameters for the metrics exports. Simply look at the commands that start –metrics_* for additional options.

For example metrics_sel lets you specify which metrics you want to report on, so if you just wanted the cyclomatic complexity and the lines of code, first you would need to clear the current metrics and then you would set the option as:

und –db c:\project\pixie.udb –metrics_sel none AvgCyclomatic CountLineCode

Then to actually generate the metrics file, use the –metrics command, you can specify the filename for the csv export, or if none is specified it will default to the last used filed location. You can see the available metrics at http://scitools.com/documents/metrics.php

und –db c:\project\pixie.udb –metrics “c:\temp\Pixie Metrics\metrics.csv”

You can set the parameters and generate the metrics with the same command, so:

und –db c:\project\pixie.udb –metrics_sel none AvgCyclomatic CountLineCode –metrics "c:\temp\Pixie Metrics\metrics 10-13-2008.csv"

You now have a comma delimited text file that you can open in your favorite spreadsheet editor, or parse however you want:

If you would rather see your metrics as an html report, use the –metrics_htmlReport command instead of the –metrics command:

und –db c:\project\pixie.udb –metrics_htmlReport current –dir "c:\temp\Pixie Metrics\html metrics 10-13-2008"

The html reports let you browse by architecture, so you can look at the metrics by filesystem, staff, or whatever architectures you have setup:

In short…. use the entity filter window to filter on “unused functions”, turn entity->long names on, then type in the name of the class. Done. 

Here are the steps….  First select the “Unused Functions” filter in the Entity Filter window:

Now, turn on Full Entity Names by clicking on the dimple to the right of the Show: field:

The names now have :: in their full name if they are from a class:

I’m looking to see if class GameBoard has any unused functions, I type “GameBoar” into the Filter: and find the methods of GameBoard that are not called anywhere in this project: