|
There is a lot of development going on these days. It involves a lot of different people with many different backgrounds. But times change, people change jobs, and the workload shifts, so the issue of standards is sure to arise. The methodology and tools to communicate and enforce those standards are missing. Additionally, a lot of that development involves large databases that reach into many parts of an organization, so the communication of standards often needs to be done in a broad manner.
Most developers would probably agree that we need standards. But if you asked those same people if they personally used standards, they would probably sheepishly reply that they do not. They cite many reasons: everything from rushed projects with no time for standards to ill-defined or nonexistent documentation of company standards. More likely than not, the problem is usually a combination of several contributing factors. In the end, it boils down to the fact that the standards are poorly documented and not enforced. Validator from Kismet Analytic Corp. addresses these concerns. Validator is a tool for database administrators, systems analysts, or other information architects to set up, disseminate, and enforce standards. Programmers can use Validator in either a referential manner to look up conventions or as an enforcement mechanism to check their work.
In short, Validator contains a database of standards in the form of naming conventions, data type standards, and field specifications. It also accepts the input of the layout of a database design. Then it makes a comparison between the standards and the actual design. You can create various reports that show mismatches, warnings, and even recommendations for fixing the problems. Validator is unique in its niche. While code review tools exist for programmers and design tools exist for database administrators, I could find no other review tools for databases.
The version of Validator I used for this review was version 1.1 of the Enterprise Edition, currently in full release. Setup, done from a normal setup.exe, was uneventful. The overall Validator installation is clean, only adding understandable directory structures and creating program groups and icons.
Starting the program will launch the toolbar seen in Figure 1 with the import screen below it. The first thing you need to do is establish valid terms and other standards. You can do this by importing valid terms and then setting up the validation standards for specific sets of data. You can type in the terms directly if they are not already documented elsewhere. You can set standards for terms, phrases, and mapping of representation terms. The representation terms are quantifiers or modifiers, such as count or field type, and are used to make sure that all fields of certain type have specified representation terms applied.
Once you set the standards, the data representing the database must be specified, mapped, and loaded. While you can import it from data in tables of many formats, such as DB2, Access, and Paradox, there is no means to read the schema of the tables in those formats. This makes no sense. In essence, you must go through the extra steps of taking the table schema and loading it into a table for reading. This lengthens the process, introducing room for error in concurrency and accuracy, and simply makes the unpleasant task of standards even less convenient. Because ODBC is used to read the contents of the tables used for the import, Kismet should take the next step and let Validator read the structure directly.
After Validator specifies the data source, it maps key concepts such as System ID, Record ID, Short Name, Alias, Length, and Data Type. Finally, after the mappings are complete, you can import the data. If there is an error in mapping, such as mismatched data types, Validator will generate an error that details where it occurred. Unfortunately, the program does not give you the option of stopping the process and correcting the error. You must proceed with the import, which stops at every record for the error. This can be quite tedious if it is a large layout.
After the data is in place, you can run an analysis that shows adherence to standards, quantifies abnormalities, and even offers recommendations for fixing the problems. It is at this point that the real usefulness of the program shows through. I was quite impressed with the analysis that the program was able to perform on unknown table layouts. Through the use of the definitions of the terms you provide, the program makes assumptions about field names and types. For example, it will catch the word "Account" if you defined it as "ACCT." It will also alert you to eight-character account numbers when the account field was defined with a length of 10. The results of the analysis can also be viewed on-screen in tabbed table format or in printed reports. Both contain the same data, and with the exception of some formatting issues, the reports were clear and the recommendations useful. You can see the presentation window of the reports generator in Figure 2.
Unfortunately, some of the report formatting issues affected the quality of the information. First, some of the reports I ran did not print labels for all fields, such as data type and length. There were also some mismatched labels on some fields, such as calling a column "File" on the report and "Record" on the screen. Finally, one general report I ran grouped results by System and File, but only put those labels on the first line of the page even if the System changed mid page. This meant that, in some cases, more than half a page of results was misidentified.
The manuals and quick start guide were informative, but showed the same lack of attention to detail that the reports displayed. Again, while not serious, these errors proved distracting and just a bit disconcerting. For example, a button named "Next" in the documentation is "Exit" in the program. These shortcomings are small things that build to an uneasy total, especially with a standards product. Even thought Kismet is a small and relatively new company, there is no excuse for poor quality.
One of the manuals included with the program is entitled Object Label Standards: A Guide to Metadata Data Element and Object Label Standards Enforcement. This short, theoretical manual gives a very good background in the science of standards, providing information on the differing philosophies of standards and some background of the DOD and ISO requirements. It provides an overview on standards beyond the rudimentary requirements, such as naming conventions.
Validator, while useful, gives the impression of a product that is just not quite done. There are many rough edges and inconsistencies between the product and the documentation. If nothing else, Validator seems like a version 1.x product that could be quite good after it has been used by customers in the field for a while so that it could benefit from feedback.
Validator is in a product category that is neither as large or flashy as data recovery or program wizards, but could prove just as valuable in a larger environment that has a need to monitor and enforce standards. I would recommend that it allow a direct connection to tables via ODBC to avoid redundant data entry. In its current configuration, however, the overhead to use the product may outweigh its usefulness, especially in smaller organizations. But with no discernable alternatives, this is the only place to turn without resorting to simple documentation, code, and schema review. If you can wait, however, send a letter of interest to the company, then bide your time for a version or two.
Figure 1. The main Validator toolbar with the import specification screen for table definitions.
Figure 2. The report screen shows an overall summary of validation errors.