Review of ROBOT/3000
Shawn M. Gordon
S.M.Gordon & Associates


ROBOT/3000 was originally developed in 1983 as an in house to to provide system documentation for an undocumented application system. Eventually this grew into the extensive cross-reference system that ROBOT is today. You can cross-reference virtually any language source that you can think of (including the popular 4GL’s that are available), JCL, SCHEMAS, and DATA BASES. For any shop that is moderately dynamic, or has most of it’s information floating around in one guys head, this is something that you should be looking into. The software is network capable, but since I didn’t have one I couldn’t look at that part of it.

I tested the software on an HP 3000 series 37 with 2 meg of memory and a 135 MG hard disk. I used my own development environment which includes several data base’s and schema’s, about 100 JCL files, 20,000+ lines of COBOL source code and a few thousand lines of C code. I had various ‘include’ files and one copylib that were also included. The sample pictures will be from the demo data that was supplied with the software so you will experience some consistency if you use this review to look at the package, that and the proprietary nature of my code. So that all said, let’s get into the software.


At it’s most basic, ROBOT will cross reference all of your ‘code’ into a single repository. This means it will tell you everything that has the string ‘CUST-NUM’ in it. So the first step to using ROBOT is to set it up, figure one, and two has a sample of the set up screen.

You can set up ROBOT one of two ways. You can manually enter all your code and the type it is in the configuration screen, or you can set it up to automatically scan selected groups and accounts. Once this scan is finished, then you can go through and modify anything that may need modifying, such as C code being defined as FORTRAN. In general ROBOT does a very good job of figuring out what type of code you have, but sometimes it just guesses wrong.

Once you have all the code defined and set up, you need to run the collection program. This can take anywhere from hours to minutes depending on the amount of code and the size of the CPU. After the initial load it will only update the indexes for files that have changed, so subsequent runs will be much quicker. This collection process should be run every day to make sure that you stay current.

Ok, now that we have set up and loaded our data the most common thing to do now would be to look for strings in our source code. This can be done in either a ‘basic’ or ‘advanced’ search method. First we will do a basic look up, refer to figure 3.

Now in this example I chose the word ‘STOCK’ as my search criteria, the ‘as a’ parameter let’s you select between ‘Name’ which would be like variable names, ‘Call’ which is intrinsic, data base, or sub-program call’s, or ‘Include/Copy’, this is any include files or copy library references. ROBOT will select ‘Name’ as the default search criteria. Now we may also select a secondary search item to be found within ‘n’ lines of the primary search. This will only find occurrences where these two search keys are within the ‘n’ lines of each other. The last parameter is what group and account to search through, this should be pretty obvious how it works.

Once everything is set up you just need to hit enter and you will be presented with a list of source code that qualifies. Now there are actually two levels of function keys here, so I will do a quick run through of what you can do from this point, this will also apply to the advanced search area.

The first thing you want to do is to mark the code that you want to work with. Once that has been done you will select a function key that will perform the function that you are interested in. So let’s say we just want to look at the area of code that has our string, we would select ‘view * files’ , we could now scan through our source and check out the are of the selected text. While in ‘view’ mode you can also set up a secondary string to search for, and go back and forth between the two search keys. While in ‘view’ mode you can also switch to ‘edit’ mode for the current work file. This will pull up whatever editor that you selected in the ‘Global Configuration’ section.

Another option is ‘Stream Compiles’. This ties into another area of ROBOT that allows you to link compile job streams to a particular piece of source code., so by selecting this option you will fire off all the compile jobs for the selected source. I am not going to get into the details of linking the compile jobs since it is so straight forward, just be aware that the option is available.

The ‘Build Workfile’ command (figure 4) is sort of an MPEXish type of facility that will build a file that contains all the commands that you specify in this screen for your selected fileset. The screen pretty much shows what all the different functions are so I won’t belabor the point here.

Another nice feature is the basic source ‘check in/check out’ facility. This is basically a small source librarian product and works more along the philosophy of ‘We trust you to use this so we all can know what’s going on’ as opposed to ‘You are going to do this no matter what’. So it relies on everyone to make sure that they go through it and refer to it when going to use code. See figure 5 for example of the check out screen. You could even use it as a project management/tracking system.

There are some pretty sophisticated print options, like showing just the cross-reference lists. Print the sections that contain the search item, the entire selected document, etc. Suffice to say that you can print just about anything, anyway you want.

The last function that I want to touch on is the ‘Advanced Search’ area (see figure 6). This is where you can enter wild card search criteria, this is different than most wild card searches because you can use a wild card at the beginning and the end of the search string. ROBOT will then scan it’s data base (very quickly) and display all the names that contain your string. You can then go through and eliminate type that you aren’t interested in if you want. You can even enter more search criteria and slowly build up a list of items to scan for. Once you have built the list the way you want it to look, you can press the function key to update the search criteria and then press the function key to find the files. Once this is all done, you can then operate on the files as described earlier.

Usability (also installation)

Since PSS was going to have some trouble generating a cartridge tape for me, we decided to go ahead and do a custom installation that could be uploaded from my PC. They were kind enough to include a full custom set of instructions for me as well. It was a little more tedious for me this way, but at least they were willing to work with me and my old equipment.


I didn’t have any occasion where the software hung or killed my system, and all the functions performed as they were supposed to. In the area of reliability ROBOT certainly shows it’s maturity.


Your major performance concern here is going to be how fast you can look up your cross-reference information. ROBOT uses a very slick proprietary indexing strategy (all implemented inside of IMAGE) that allows them to do VERY fast lookups using wild-cards before and after a string. I was able to look up variables in my source code on my 37 in a negligible amount of time.

The data collection is a bit of a CPU pig, but since you are only going to do at non-peak hours anyway, it is worth the usage. So the bottom line is ROBOT is fast where it needs to be, and it is slower where you aren’t going to notice it.

Supportability (including Doc)

The support from PSS is excellent and friendly, I never had any problems getting an answer to a question or in getting a hold of a warm body. The manual however is a little tough to get through, it is laid out in the order of the menu items, not in the order that you would necessarily follow to get set up. There is a whole demo area that get’s set up in the installation, but no demo guide or quick walk through to help get you going. On the plus side, they do an hour long phone walk through of the demo data, just make sure that you take notes. There is also extensive on-line help at every stage of the product that will guide you in how to maneuver through it.


Let’s start with the complaints first. I would have like to have seen slightly more dynamic function keys, so only the keys that were applicable at a given moment were the ones that were displayed. I would have liked to have seen a demo guide that basically followed the same steps as the phone walk through.

Things that I really liked included the extensive ‘help’ facility at virtually every level. The ability to configure the product extensively through the use of ‘JCWs’. And the sophisticated indexing and search facilities. The ability to jump from one function to another without having to back up to the main menu is also very nice.

There are other products that will search for strings, or make indexes of text. There are also other products that will do source code management (check in/check out). There are even products to check your data set capacities and give you a trend. But I don’t think there is anything that combines Source cross-referencing, with revision management, and data trending in quite so concise a package, especially one as solid as ROBOT appears to be. This is really a wonderful tool, I just can’t believe it took me this many years to look at it.

At-a-Glance box

ROBOT/3000 version 7.34
Productive Software Systems Inc.
5810 West 78th St.
Minneapolis, MN 55439
Phone: 612-831-8866
FAX: 612-831-3293

Software ranges from $4,000 to $12,000 depending on the CPU. Maintenance is 20%, network node and right-to-copy pricing is also available. There is also a new UNIX version available. Call, write or FAX for a demo or information.