SV Surprises With A New .NET Template Engine

by Dave Harms

Published 2009-10-16    Printer-friendly version

Note: The following comments are based on the ClarionLive! webcast of Bob Zaunere's Aussie DevCon presentation. The video and audio link imposes certain limitations; I apologize in advance for any inaccuracies. And my sincere thanks to Geoff Spillane, Arnold Young and John Hickey for making the webcast happen.

In his opening address to the Aussie DevCon, SoftVelocity president Bob Zaunere gave a brief but remarkable presentation on the new Clarion.NET Application Generator.

In short, the new AppGen is a game changer.

Bob described how, in the process of developing the new Clarion.NET AppGen, they went down the path of creating .NET templates using the existing template language. And they found out that although they have a powerful Win32 generator, one thing made that product possible: Clarion's own special set of user interface controls (buttons, list boxes, etc).

In .NET, all that changes. The standard set of controls is much larger, and beyond that is a whole world of third party controls.

The short path was to support the standard controls only, using the existing template engine.

The longer path, the one SV is taking, is a new AppGen built on a template language that is 95% written in C#. These templates are compiled into assemblies, so for the first time Clarion will have compiled templates. And because the templates are .NET code you can debug them with the .NET debugger.

Bob Z pointed out that in any complex system the vast majority of the code is not the user interface. The AppGen he demonstrated wasn't really an AppGen, more a temporary interface (created over the course of a week) on top of the new template engine. On the left side pane was a procedure list. On the right, a set of property grids. It was difficult to see on the web cast, but the point wasn't so much the crude demo interface but the way template prompts were presented in property grids. Each property in a template can have its own property editor, which is a far more configurable system than the current AppGen.

Design goals for the new AppGen include:

• Version control - the app format is 100% XML and version control friendly (Subversion)
• You have access to any .NET control/component/service from the template language
• The ability to attach developer documentation/notes to app and or to individual procedures.
• Option to generate test cases for aspects of the APP (nUnit)
• Support fo all Clarion-standard code templates, e.g. call procedures on lookup, instantiate procedure on thread, export to XML
• Template support for Actions for any .net control including controls from third party vendors ("best efforts")
• Template language code used in the first release is C# (for ease of debugging), subsequent releases can use any .NET language.
• Layered interface - you can determine the level of detail you want to work with
• A much flatter interface

Design goals for the generated code include:

• All of the business rules and business validation logic will be generated in a domain model tier and not within the UI tier
• The data access tier uses LINQ via SV's LINQToFileProvider, LINQToSQL, and future LINQ providers
• The data access tier can use the managed .NET IP driver
• The LINQToFileProvider incorporates an ABC-style framework - think of it as the best of ABC on top of LINQ
• LINQ to SQL is itself a lightweight ORM; the templates are being designed so that in the future they could generate using other heavier ORMs such as Entity Framework, NHIbernate, CSLA etc.
  

The intent is to be able to create code for WinForms, WebForms, CompactForms and web services. Apps generated for each target platform use essentially the same design for the generated code.

Bob asked for requests and ideas for the new AppGen. It was difficult to hear some of the questions over the web link but there was some discussion around dictionaries, including support for multiple dictionaries.

Closing quotes from Bob Z's presentation:

Imagine this - you will generate Clarion styled database applications for every platform supported by .NET without having to be a .NET expert or even writing any .NET code

Each target platform utilizes essentially same design pattern for the generated code (learn one and know them all)

Conclusions and impressions

I was pleasantly surprised (actually gobsmacked is probably a better term) by Bob Z's announcement of a new .NET template engine written in C#.

It may be difficult for most Clarion developers to fully appreciate the significance of this project. One very good way is to spend a whole lot of time writing a template chain in C6 or C7 to generate .NET code, as I've been doing over the last year and a half. You quickly come to appreciate the unique power of the template language, as well as the maddening frustration of not being able to extend the template language itself with .NET code for all those tasks for which the template language, as it is now, is poorly suited. And you wish often for a real template debugger, but you settle for OutputDebugString and DebugView.

In my case I'm writing templates for MVC web apps (in support of, among other things, a new ClarionMag site) and thanks to the nature of the MVC pattern I don't need to rely on the C7 window designer for much more than simply placing controls on a form in a given sequence. Position, appearance is all up to the style sheets. But my, it would be so nice to be able to invoke a different editor here, or a certain bit of .NET code there.

All of that is what the new template engine offers.

I've long argued that the great value of Clarion is not in the Clarion language itself. Oh, the language has its fans, and probably a majority of Clarion developers think much more highly of it than I do.

But let's face facts: although we're a (sort of) loyal and (sometimes) tightly-knit community, we don't have a lot of young blood. If Clarion is to survive, and thrive, it has to grow beyond its current borders. And it will do that by becoming a compelling solution for folks who aren't interested in the Clarion (or Clarion#) language.

The new template engine offers that hope. Until now it's been a daunting task to create an entire application template chain for other languages, in large part due to the limitations of the AppGen and the near impossibility of debugging the templates. It appears likely that SoftVelocity will focus on Clarion# templates, and that's as it should be. Let others bring out the C# and VB.NET templates, or perhaps IronRuby templates - who knows?

The new template engine has the potential to liberate Clarion's code generation technology from its Clarion-centric limitations. And that would be a very good thing, both for the Clarion community and for the wider world of .NET programming. Even if you don't care one iota for .NET, if you rely on Clarion in any form you surely care that SV survives and prospers.

But a note of caution is also in order. Keep in mind that:

• This is an early demo - it may be some time before a usable version appears.
• SV has its existing Win32 customer base to tend, and that takes resources too. A solid 7.1 release is essential.
• The plan for a common architecture for WinForms, WebForms and CompactForms is ambitious.

In other words, the proof is in the pudding. But certainly the direction SV is taking looks most promising, and much better than I had hoped. I believe a fully .NET template language and AppGen is exactly the right approach.

---

David Harms is an independent software developer and the editor and publisher of Clarion Magazine. He is also co-author with Ross Santos of Developing Clarion for Windows Applications, published by SAMS (1995), and has written or co-written several Java books. David is a member of the American Society of Journalists and Authors (ASJA).

Printer-friendly version

Copyright © 1999-2009 by CoveComm Inc. All Rights Reserved. Reproduction in any form without the express written consent of CoveComm Inc., except as described in the subscription agreement, is prohibited.

Clarion Magazine ISSN 1718-9942