Time2HELP 2.0 Info
We are currently migrating Time2HELP 2.0 to .NET. Even though we've come quite
close to having Time2HELP 2.0 ready (implemented using Delphi for Win32), we've
concluded that .NET is a perfect platform for a tool like T2H, and therefore
that it is in the best interest of our product (and our users) that we migrate
it to the .NET platform. It is not a trivial migration, because obviosuly we
want to utilize some essential technologies that now has become available to the
development of T2H.
Main Goal: Customizability and power
The typical T2H user is a developer, and we have to say, statistically a very good developer! Many years ago we got a mail from an enthusiastic user (living in another part of the world) who was so happy with our product that he wanted to do work for us. For free!
Unfortunately, we had to turn down his generous offer because our architecture back then was very inflexible, we figured we would spend about the same amount of time specifying what this person should do (and help him implement it with our architecture), than to simply do it ourselves. For T2H 2.0, we will not need to "hand-hold" developers wanting to extend T2H, the architecture and documentation will enable developers to add features completely on their own.
T2H 2.0 will continue to support documenting Delphi source code (both native and Delphi Prism). It will have out-of-the-box support for MS HTML Help 1.x and 2.0 and generic XML. Perhaps the old WinHelp output as well, if we register interest for it.
In addition to the traditional "outputs", T2H 2.0 will feature another mode of
interacting with information/documentation.
Template System Improvements
In Time2HELP 1.0 we decided to use an output template system in order to provide flexibility, we believe that there will always be users who will not be completely satisfied with any given finite set of options to tweak a hardcoded output. However, the template system in 1.0 had a lot of limitations, it was basically undocumented, there were no inheritance among templates, meaning one ended up "burning the bridges" to updates to the standard templates if one were to build custom templates. In addition, there were a lot of hidden/undocumented rules about what objects could be accessed when, and collections and their sorting order were hardcoded.
Fortunately, in T2H 2.0, all of these limitations have been addressed. :-)
The 2.0 analogue to templates are documented, there will be live diagrams within T2H displaying the object model available to templates, and an editor will make it easier to understand and write them. The new system supports inheritance (and overriding), meaning you can subclass the standard templates and override only the aspects you really want to change/customize. There will be no "hidden rules" as to what objects can be accessed when in the output templates, the object model can be traversed without fear of access violations.
Templates Generalized Into Scripts
In 1.0, output templates controlled the overall contents and the look of the output, and they were invoked during the build process to build the outputs. During development of 2.0, we realized that the new template system had suddenly gotten powerful enough to generalize/encode the build process itself, not only the output template part. This results in a lot of flexibility for power users, it is now possible to customize the build process itself, doing things like copying resulting output to wherever you want, rename files, ftp-upload html files to web servers, transform the in-memory representation of the code after having been loaded, but before being written to output etc. (T2H 1.0 has essentially been reduced to a handful of script instructions...)
In-Memory Object Database
The scripting engine wouldn't be complete without access to all interesting/useful information T2H has about your project, so in order to make sure the scripting engine has full access to all info, we store all info in some kind of lightweight in-memory OO "database" during the build process. (To give you an idea, Delphi code has a database scheme similar to: A Unit has 0..n Classes, a Class has 0..n Properties, a Class may have an AncestorClass, anything may have a Summary etc.)
This data model is extensible, if you want to attach some other info to classes (or whatever), which scripts can react/work on, you can do that.
The Scripting Language
We have designed and implemented our own scripting language for T2H 2.0,
This scripting language is optimized for processing various kinds of inputs, accessing info in the T2H in-memory database and generating text based outputs.
The scripting language is fully buzzword compliant in that it is a statically typed object oriented lanugage supporting obvious features like inheritance
and polymorphism, but also somewhat more esoteric features like lambda expressions (via OCL), type inference and multi-methods. Unlike well-known *dynamically* typed scripting languages like Python, Perl, Ruby and PHP etc, the T2H scripting language is *statically* typed.
OCL (Object Constraint Language) Support in Scripts
T2H 2.0 scripts employ a subset of OCL (Object Constraint Language, a part of the
UML standard) to query T2H 2.0's in-memory database (and for expressions in general). (For those who don't know OCL, but knows SQL, in T2H 2.0, OCL is employed as a sort of "SQL for objects".
Also quite similar to MS' LINQ.).
(We might do one small syntactic tweak to OCL implementation though, there's a little syntactic detail we're not thrilled about)
Scripts + In-Memory Object Database = Power
This results in a highly customizable/flexible system, both regarding input and output. If you have some kind of structures you want documented, you can extend Time2HELP to "understand" your structures by extending the object model to incorporate your structures and writing a Time2HELP 2.0 script transforming your info into T2H's in-memory database or by writing an addin in
your favourite .NET language doing the same. Then you will be able to use the general features of Time2HELP 2.0 to manipulate this "foreign" information, like add it to your help files, combined with the other info Time2HELP has available.
As an example, the architecture will be flexible enough to enable thirdparties to add seamless support for features like documenting .NET assemblies.
T2H 2.0 as a Code Generator Tool
Since the scripting language of T2H is optimized for processing various kinds of information and generating text based output, it is well suited as a tool for writing code generators. We believe T2H 2.0 can be used as part of a MDA (Model Driven Architecture) toolset.
DatabasesWe haven't finalized yet which (standard) database engines will be supported out of the box, but for those that will be supported, you can query these databases via SQL (from within T2H 2.0 scripts) and include this info in your help files. (It will be possible for power users to write addins to support database engines not supported by us "out of the box"). Generic database interfaces like ADO will be supported out of the box.
When will it be released?
"When it's ready"
Will it support MS HTML Help 2 Output?
I recently bought 1.0!
License holders that "recently" bought Time2HELP 1.0 will get a free upgrade to
Time2HELP 2.0. Since we've spent so much time developing T2H 2.0, we will also
provide all long time customers with a free upgrade. In essence, everyone having
a licence of T2H 1.0 will get a free upgrade to 2.0. :-)
Will T2H 2.0 be bloatware?
Yes and no. We want to utilize the best technology available for this kind of
tool. Currently we're using .NET 3.5 SP1, we might require .NET 4.0 for T2H 2.0.