November 13, 1995
By Peter Coffee
| Corporate Buyers' Advisory | Corporate Scoreboard | Test Methodology |
TopSpeed Corp.'s Clarion for Windows 1.5 is a fast, stylish, and reliable vehicle for developers of data-driven applications who want to use the 32-bit power of Windows 95 and Windows NT -- without abandoning their 16-bit Windows users.
Like a new-model car, the $499 Clarion that reached the showroom last month has more power under the hood in the form of a 32-bit compiler -- augmenting, rather than replacing, the 16-bit engine that's still included. Clarion applications can now be built for either 16- or 32-bit deployment, with surprising consistency: Native features of the Windows 95 shell are emulated by Clarion when an application is deployed on Windows 3.x, while Level 1 16-bit Visual Basic control extensions are brought forward from Windows 3.x to the 32-bit Windows 95.
Clarion also has a hot new automatic transmission in the form of a sophisticated Application Wizard that can generate surprisingly complex applications without manual coding. Finally, the new model's sheet metal has been restyled with a more streamlined user interface that makes the product's options more accessible.
The Clarion language, with its COBOL-like formalism, may put off developers who are attracted to the ad hoc conciseness of Microsoft Corp.'s Visual Basic or the trendy object orientation of Borland International Inc.'s Delphi. But we were truly impressed by the ease and precision with which Clarion's compiler, aided by that formal syntax, identified our errors (accidental and otherwise) and made them accessible for quick correction. Like COBOL or Ada, Clarion rewards developers with outstanding readability and ease of maintenance in return for a little more effort up front.
The Clarion language also offers Ada-like string operations, LISP/REXX-like run-time expression evaluation, and COBOL-like binary-coded decimal arithmetic exactness. It would be a mistake to stereotype Clarion as merely a database front-end tool: Clarion is also a language that a developer could really come to rely on.
But Clarion shares the same back end as other development tools from TopSpeed, and a Clarion application can therefore incorporate modules written in Modula-2 or C/C++ merely by adding the appropriate compiler DLLs (dynamic link libraries), which are sold separately. We did not test this aspect of the product, but it offers development shops the prospect of using readily available C/C++ development skills for many portions of a project while still getting the benefits of the Clarion language and environment for top-level code and for project organization.
Development tools When it comes to prototyping, Visual Basic or Delphi may do a quicker job of building a pretty face without any data behind it, but Clarion is unrivaled for its ease of constructing an attractive graphical application that does real work. Clarion's advantage looks smaller, however, when one considers the huge range of third-party add-ons available for the Microsoft and Borland products.
As we noted in our previous review of Clarion 1.0, most other rapid development tools begin with a blank screen to be populated with controls; Clarion begins with an empty data dictionary to be populated with field descriptions and database key types. From there, Clarion automatically generates a useful suite of views and tools for browsing, updating, and reporting that data.
With the data dictionary as a foundation for everything else, Clarion's graphical tools for defining on-screen forms, queries, and reports are always aware of data types and formats, allowing convenient previews of the appearance of fields and tables of data.
Though not as rich as the query-building aids of Integra Technology International Inc.'s Business Application Builder for Visual Basic, Clarion's tools proved quite capable -- especially when a data dictionary was updated during development, where Clarion excelled in its ease of propagating those changes rather than starting work essentially from scratch.
User-interface elements were easy to define and manage with Clarion's palette of interface objects. Here again, close ties to the data dictionary accelerated development by offering rapid creation of prompts and data-entry controls for fields of the project database. Other tools, such as aids for aligning visual elements, were extensive and convenient.
The graphical window formatter and the source-code text editor are also well integrated, which allowed us to view and graphically edit a window layout by placing the text editor cursor within the window's defining code and typing Ctrl-F. Any changes that we made using the graphical editor appeared in our source code when we returned -- we found the bidirectional interaction between graphical and text-based tools smoother than Delphi's.
Performance We can see that even the first component of the benchmark suite we are building for 32-bit development systems delivers important insights into the core efficiency of tools such as Clarion for Windows and Visual Basic. In the 16-bit realm, we had previously found Clarion for Windows 1.0 to be 26 times faster than Visual Basic 3.0 in iterations through a loop with no other function; Visual Basic 4.0 appeared to have narrowed this gap substantially, with Clarion 1.0 only nine times faster than 16-bit Visual Basic 4.0. But when running the 32-bit Tak benchmark that we introduce in this review, using declared integer variables, Clarion for Windows 1.5 proved 15 times faster than Visual Basic 4.0.
Developers should also note the severe penalty incurred by Visual Basic when variables internal to Tak were not explicitly typed, while the Tak function itself was declared to return an integer: This slowed down the Visual Basic times by an additional factor of 2.2. This was not merely due to type conversions because declaring the internal variables as single-precision real numbers while leaving Tak defined to return an integer caused only a 27 percent slowdown compared to using integers throughout. BASIC developers who ignore their optional variable type declarations as an archaic nuisance should ponder these results, while Clarion developers enjoy the efficiency benefits that come from giving the compiler plenty of information on what one is trying to do.
We should acknowledge, however, that Clarion's advantage shrinks dramatically when it is used -- or should we say misused? -- for intensive scientific or other floating-point computation. While a double-precision floating-point Tak is only 1.15 times slower than an integer Tak under Visual Basic 4.0, the corresponding penalty in Clarion for Windows 1.5 is a factor of 9.4 (though this still leaves Clarion almost twice as fast as Visual Basic 4.0).
The run-time DLL required to support a 32-bit Clarion application is actually smaller than the one that accompanied the 16-bit 1.0 release, weighing in at 512K bytes -- almost petite compared to the 704K DLL that accompanies a Visual Basic 4.0 application. For more convenient distribution, Clarion now offers the option of linking the DLL into the executable file at the expense of redundant disk usage by multiple applications.
Underlying architecture The Clarion language is clearly a result of design, while BASIC -- not to mince words -- has merely grown. There is simply no comparison between the rigorous consistency checking abilities that Clarion developers will enjoy and the "please do what I meant" that too often passes through the mind of even the experienced programmer using BASIC (or even C).
Developers will also benefit from the pains that have been taken to document efficient procedures and alternative approaches to multiprogrammer development in the Clarion manuals. Though not in the same class as, for example, Symantec Corp.'s C++, Clarion is clearly a system that could be used without frustration by fairly large teams -- but only with external discipline, rather than by means of built-in facilities or data structures.
Object-programming support As we noted in our review of Version 1.0, the Clarion language is not object-oriented, although its use of so-called "property expressions" gives an object-oriented flavor to many operations on windows, views, files, reports, queues, and even entire applications.
Clarion's model of template extension also provides mechanisms like those of object-oriented inheritance, though with more flexibility for sharing separately developed extensions without a strictly hierarchical relationship.
Further, the Clarion environment yields many of the benefits that are supposed to come from object technology. From the moment that even a minimal application has been built by the automated aids, the Clarion environment provides a tree-structured view of the components of the application.
This hierarchical browser has some ergonomic blind spots, however. For example, a developer must click on an Edit button rather than just double-clicking on the icon for a source file to open that file for editing.
And as we have emphasized before, the Clarion data dictionary provides a rock-solid foundation for everything else in an application under construction, with excellent facilities for making sure that consistency is preserved between data and all of the logic that manipulates it.
Clarion's dictionary-based approach is not the same thing as classical object-oriented encapsulation, where code conceals the underlying data and allows only published methods to inspect or change it -- but the biggest benefit of encapsulation is that it ensures consistency, which Clarion merely ensures in a different way.
Database support Clarion provides a panoply of drivers for ASCII, BTrieve, Clipper, dBASE, and FoxPro data and index files, in addition to an ODBC (Open Database Connectivity) driver. Documentation for these various drivers includes not only "how it works," but also "when to use this" information -- the sort of thing we wish more tool makers would provide, rather than leaving developers to search through bookstores for additional help at $35 a volume.
When using a remote server via ODBC, the Clarion language permits embedding a SQL statement as a data structure property, then using Clarion functions to trigger such operations as retrieving the next record. The result doesn't feel like either the hands-on approach of xBase programming or the "let it rip" of pure SQL, but rather like a distinctive and not unpleasant hybrid.
Desktop integration and platform support Clarion could be a multiplatform tool if TopSpeed thought that the non-Windows market was big enough to be worth the cost of supporting multiple versions. The TopSpeed back end already exists for OS/2, so only the development environment would need to be ported anew to the OS/2 Workplace Shell. Unlike Visual Basic 4.0, Clarion is not tightly coupled with Microsoft's OLE, though OLE services are available through API calls, and Dynamic Data Exchange is supported by a library of high-level functions.
But Clarion for Windows isn't burning any lanterns in the North Church tower. You won't find Clarion developers riding through the night, crying, "Follow me to platform independence." Clarion's documentation mentions OS/2 precisely once--and that in a historical context. Draw your own conclusions about TopSpeed's estimate of the size of the OS/2 development market.
Documentation and support Clarion for Windows comes with three printed manuals: Getting Started, Users' Guide, and Language Reference. We found them exemplary in completeness and organization if a bit heavy-handed in their typography. (Someone at TopSpeed really likes Boldface Helvetica SmallCaps.) But ample use of halftone screen photos, useful tips on effective techniques, and an online global index to all three volumes make these manuals a model for competing companies.
We found an extensive developer community in a Clarion 1.5 area on the CompuServe TopSpeed Forum, with current postings of 646 messages in 222 topics. A spot check of several topics showed helpful TopSpeed responses, where called for, typically within 24 hours.
Clarion for Windows 1.5
TopSpeed Corp.
(800) 354-5444
(305) 785-4555
Analyst's Choice
Visual Basic 4.0 Enterprise Edition
Microsoft Corp.
(800) 426-9400
(206) 882-8080
Analyst's Choice
Reviewed Oct. 2, 1995
Bottom Line: For developers whose applications are shaped by underlying data, the automated aids in Clarion for Windows 1.5 will deliver a strong foundation in minutes, with advanced application features being readily shared among teams of developers through Clarion's advanced system of extensible templates. Visual Basic 4.0 will be more appealing to those who want to repackage the modular functions of OLE-capable Windows applications into customized business solutions.
| Product | Clarion for Windows 1.5 | Visual Basic 4.0 Enterprise Edition |
| Vendor | TopSpeed Corp. | Microsoft Corp. |
| Reviewed | Nov. 13, 1995 | Oct. 2, 1995 |
| Comments | Analyst's Choice | Analyst's Choice |
| Development Tools | ||
|---|---|---|
| Initial prototyping | Excellent | Excellent |
| Query and report creation | Good | Excellent |
| Adding and refining user-interface elements | Excellent | Excellent |
| Performance | ||
| Processing speed | Excellent | Good |
| Interactive operations | Excellent | Good |
| Resource usage and requirements | Good | Good |
| Underlying Architecture | ||
| Strength of programming language | Excellent | Good |
| Version control | NA | Excellent |
| Group development support | Good | Good |
| Strength of repository | Good | Fair |
| Object-Programming Support | ||
| Clarity of application structure | Excellent | Good |
| Encapsulation of data and logic | Excellent | Excellent |
| Ease of identifying and reusing components | Excellent | Excellent |
| Database Support | ||
| Database driver support | Excellent | Good |
| Efficiency of using database-server functions | Excellent | Good |
| Ease of defining database-server connections | Good | Excellent |
| Desktop Integration | ||
| Support for interapplication APIs on native operating system | Fair | Excellent |
| Import/export capabilities | Good | Good |
| Platform Support | ||
| Windows | Excellent | Excellent |
| Macintosh | NA | NA |
| OS/2 | NA | NA |
| Unix | NA | NA |
| Documentation and Support | ||
| Ease of installation and learning | Excellent | Excellent |
| Reference materials | Excellent | Good |
| Vendor assistance | Good | Good |
We installed Clarion for Windows 1.5 under Windows 95 on a Micron Electronics Inc. P90PCI machine with a 90MHz Pentium processor and 16M bytes of RAM. We evaluated Clarion's development tools using tutorial exercises and sample programs provided with the product and while rewriting the Tak benchmark in the Clarion language.
We measured execution speed with a variety of numeric data types on the same machine, using 32-bit deployment options for all tests.
Copyright (c) 1995 Ziff-Davis Publishing Company. All rights reserved. Reproduction in whole or in part in any form or medium without express written permission of Ziff-Davis Publishing Company is prohibited. PC Week and the PC Week logo are trademarks of Ziff-Davis Publishing Company. PC Week Online and the PC Week Online logo are trademarks of Ziff-Davis Publishing Company.
JF