[news.eclipse.technology.ldt] Project similar to LDT

[richard.davies@xxxxxxxxxxxxxxxx (Richard Davies)]

Hi All,
  I was creating a language building framwork when I came across the LDT 
project. I will describe what I have been aiming 

for, and why and maybe you can tell me any of:
1. If you have any ciriticisms / comments about my project?
2. If there is anything that already exists that might help me?
3. If there is any way we could work together?


I am using XSD to desribe my language model. The main reason for this is 
there is lots of support for parsing and transforming XSD/XML, and it is 
self describing.

My immediate goals are:
1. To automatically generate a form based editor that respects any 
language I have defined in an XSD.

2. To ensure the form based editor minimises (eliminates if possible) any 
syntax errors in the program. I.e. the code should always be as 
syntactially correct as possible even as it is being written.

3. To be able to customise the form based editor's interface by using a UI 
preferences document. For example, if the visibility if a member is to be 
filled in on the form based editor, the graphical component that does this 
could be a drop down list or a radio button set. Likewise, the component 
could be present next to the code where the method name appears, or in a 
propery pane, or a dialog box. This is only an example, but for each 
element of the schema that models the language, a certain representation 
of that element in the form can specified in an associated document. I 
call this dcoument the "xsd to ui mapping document".

4. To create a semantic information document for the language. This 
document would (for exmaple) define a link between a variable usage and 
the field/parameter/local declaration of that variable. This information 
could then also be used when generating forms that not only validate code 
but to aid in code entry. For example, if a variable was entered and it 
did not match any variable that was in scope, the editor could suggest the 
creation of such a variable. Likewise, if a variable's name were changed, 
the editor could automatically do a "refactoring"-style rename of that 
variable in all locations where it was semantically linked. All of these 
things are already present in eclipse but the key point is that the editor 
could automatically figure out where there is a semantic problem as 
suggest automatic fixes (within the constraints of the xsd to ui mapping 
document). These semantic links would be stored in the "language semantics 
document".

Benefits (aside form those listed above):
1. It is possible for code in the program to be freed of certain 
constraints - for example, the need for keywords dissapears, 

so they can be used as identifiers.

2. As XSD is self describing, the same infrastructure that is used for 
writing programs can be used for creating the languages themselves. 
Likewise the "xsd to ui mapping" and "language semantics" documents could 
be edited using the same infrastucture.

3. Individual developers can customise the ui mapping document to their 
wishes. This could given the different (potentially VERY different) view 
of the same code that is being edited.

One of my long term goals is to create a language that compiles to Java 
bytecode where all programming types are XSD types. 

This will have various uses:
1. The form based editor can ensure that any literals conform to the XSD 
of the data types. The program could be in its own right a powereful data 
repository that could be used instead of (or linked to - see next point) a 
database.

2. Mapping the data types to a database can also generate the appropriate 
constraints in the database. Reverse mapping of an existing database will 
also preserve much more (all?) of the data typing/constraint information 
that is defined in the database schema.

3. Creation of platform independent validating UIs. The data type 
information and the xsd to ui mapping document could generate 
web+javascript, Swing, SWT, XUL or any other type/description of widgets 
that are data-type aware and can validate data or ensure invalid data is 
never entered. These widgets could form a "custom palette" of UI 
components used to build the application interface.

Regards
Richard Davies

Skills Matter
richard.davies at skillsmatter.com