«

Hi,

RefleX is a Java tool that allows people that have no particular
knowledge of Java to write smart programs entirely in XML. The concepts
of native XML programming used in RefleX have been designed separately,
so that other implementations on other platforms/languages can be
considered. As the tags used are considered "active", the underlying
concepts have been named "Active Tags". Programming in XML allows
developers to efficiently produce batch scripts as well as Web
applications. With Active Tags, you can dramatically decrease the number
of lines you have to code.

RefleX 0.1.3, a general-purpose XML Virtual Machine, is available here :
http://reflex.gforge.inria.fr/

In this release, you'll find tutorials for mapping SQL to arbitrary
complex XML structures, and for experimenting the Active Schema Language
: express constraints on XML documents that you can't achieve with DTD,
W3C XML Schema, neither Relax NG, and define custom semantic data types.

Enjoy !

--
Cordialement,

///
(. .)
--------ooO--(_)--Ooo--------
| Philippe Poulard |
-----------------------------
http://reflex.gforge.inria.fr/
Have the RefleX !

On Wed, 29 Mar 2006 14:11:35 +0200, Philippe Poulard
<> wrote, quoted or indirectly
quoted someone who said :

>RefleX is a Java tool that allows people that have no particular
>knowledge of Java to write smart programs entirely in XML

That strikes me as like saying "X is is a tool for people who have not
yet learned to drive to drive blindfolded encased in bubblewrap." XML
adds many level of DIFFICULTY. Look at ant. Even the simplest things
become hideously awkward.

--
Canadian Mind Products, Roedy Green.
http://mindprod.com Java custom programming, consulting and coaching.

On Wed, 29 Mar 2006 21:44:59 +0200, Roedy Green
< > wrote:

> On Wed, 29 Mar 2006 14:11:35 +0200, Philippe Poulard
> <> wrote, quoted or indirectly
> quoted someone who said :
>
>> RefleX is a Java tool that allows people that have no particular
>> knowledge of Java to write smart programs entirely in XML
> That strikes me as like saying "X is is a tool for people who have not
> yet learned to drive to drive blindfolded encased in bubblewrap." XML
> adds many level of DIFFICULTY. Look at ant. Even the simplest things
> become hideously awkward.
>

I am stumped trying to find a problem that this would solve.

Now what we really need is a mark-up format for XML, so we don't have to
write XML directly. Here's a first stab:

[Element name="myElement"]
[Attribute name="myAttribute" value="myValue" /]
[Content]My textual content.[/Content]
[/Element]

This would could then be compiled into the native XML. This approach
neatly decouples the document mark-up from the concrete implementation of
the mark-up language, allowing the data to me compiled to any
heirarchical, text-based mark-up language that you chose. Here's how the
XML output might look:

<myElement myAttribute="myValue">
Please somebody stop this nonsense.
</myElement>

Dan.

--
Daniel Dyer
http://www.dandyer.co.uk

On Wed, 2006-03-29 at 22:29 +0200, Daniel Dyer wrote:
>
>
> [Element name="myElement"]
> [Attribute name="myAttribute" value="myValue" /]
> [Content]My textual content.[/Content]
> [/Element]
>

I know you're joking, but I've seen meta-markup that was just as silly,
in a serious context.

On Wed, 2006-03-29 at 19:44 +0000, Roedy Green wrote:
>
> That strikes me as like saying "X is is a tool for people who have not
> yet learned to drive to drive blindfolded encased in bubblewrap." XML
> adds many level of DIFFICULTY. Look at ant. Even the simplest things
> become hideously awkward.

I disagree, for ant, except in degenerate cases where the project is
simpler than the build script.

Now, XSLT functions. Iterating through a data structure, sorting,
searching, formatting, that sort of thing in XSLT is always a
nightmare.

"Daniel Dyer" <> wrote in message
news...
>
> Now what we really need is a mark-up format for XML, so we don't have to
> write XML directly. Here's a first stab:
>
> [Element name="myElement"]
> [Attribute name="myAttribute" value="myValue" /]
> [Content]My textual content.[/Content]
> [/Element]
>
> This would could then be compiled into the native XML. This approach
> neatly decouples the document mark-up from the concrete implementation of
> the mark-up language, allowing the data to me compiled to any
> heirarchical, text-based mark-up language that you chose. Here's how the
> XML output might look:
>
> <myElement myAttribute="myValue">
> Please somebody stop this nonsense.
> </myElement>

Yes, but then someone would have to actually LEARN your meta markup
language. We should have a descriptive language which allows you to define
the syntax for your language, and it should look as much like plain English
as possible, so that anybody could read it. We'd start off with an
identification division, so that we could uniquely refer to these template
languages for maximum re-use, then describe the encoding that the file uses
so that parsers could... well... parse them.

000100 IDENTIFICATION DIVISION.
000200 TEMPLATE-ID: DanielDyerMarkupLanguage.
000300 AUTHOR: Daniel Dyer, Oliver Wong.
000400 ENVIRONMENT DIVISION.
000500 SOURCE-ENCODING: ASCII.
000600 LINE-ENDINGS: Unix.
000650 FILENAME-EXTENSION: ".ddml".
000700 MAIN-DESCRIPTION DIVISION.
000800 CASE IS: Significant.
000900 WHITESPACE IS: Insignificant.
001000 TAG-OPENING-STRING IS "[".
001100 TAG-CLOSING-STRING IS "]".
001200 TAG-END-MARKER IS "/".
001300 SHORT-CUT-TAGS ARE Allowed.
001400 ELEMENT-STRING IS "Element".
001500 ATTRIBUTE-STRING IS "Attribute".
001600 NAME-ATTRIBUTE-STRING IS "name".
001700 VALUE-ATTRIBUTE-STRING IS "value".
001800 CONTENT-STRING IS "Content".
001900 END-MARKUP-DESCRIPTION.

There, now people (and more importantly, computers) can understand how
to use your generic markup language! The line numbers are present so that
copy-and-pasting code snippets in the wrong order can be detected and
rectified. The practice is to increment them by 100s, in case you need to
later insert a line (as I have done so; can you spot where?)

I wasn't sure if you intended for your markup language to be case
sensitive or not, so I arbitrarily guessed that it was.

- Oliver

Philippe Poulard wrote:
> Subject: Don't you need an XML Virtual Machine ?

Ah, a solution in search of a problem.

/Thomas
--
The comp.lang.java.gui FAQ:
ftp://ftp.cs.uu.nl/pub/NEWS.ANSWERS/...g/java/gui/faq
http://www.uni-giessen.de/faq/archiv....java.gui.faq/

Daniel Dyer wrote:

> I am stumped trying to find a problem that this would solve.

I think the idea is that it /causes/ the problems...


> [Element name="myElement"]
> [Attribute name="myAttribute" value="myValue" /]
> [Content]My textual content.[/Content]
> [/Element]

[Grin/]

-- chris

Roedy Green wrote:
> On Wed, 29 Mar 2006 14:11:35 +0200, Philippe Poulard
> <> wrote, quoted or indirectly
> quoted someone who said :
>
>
>>RefleX is a Java tool that allows people that have no particular
>>knowledge of Java to write smart programs entirely in XML
>
>
> That strikes me as like saying "X is is a tool for people who have not
> yet learned to drive to drive blindfolded encased in bubblewrap."

I mean : people that have a knowledge of computer sciences can use
RefleX even if they don't know Java, because entire applications can be
written exclusively with tags in RefleX. But if you want to embed some
existing Java classes, you're welcome !

XML
> adds many level of DIFFICULTY. Look at ant. Even the simplest things
> become hideously awkward.
>

--
Cordialement,

///
(. .)
--------ooO--(_)--Ooo--------
| Philippe Poulard |
-----------------------------
http://reflex.gforge.inria.fr/
Have the RefleX !

Oliver Wong wrote:
> "Daniel Dyer" <> wrote in message
> news...
>
>>
>> Now what we really need is a mark-up format for XML, so we don't have
>> to write XML directly. Here's a first stab:
>>
>> [Element name="myElement"]
>> [Attribute name="myAttribute" value="myValue" /]
>> [Content]My textual content.[/Content]
>> [/Element]
>>
>> This would could then be compiled into the native XML. This approach
>> neatly decouples the document mark-up from the concrete implementation
>> of the mark-up language, allowing the data to me compiled to any
>> heirarchical, text-based mark-up language that you chose. Here's how
>> the XML output might look:
>>
>> <myElement myAttribute="myValue">
>> Please somebody stop this nonsense.
>> </myElement>
>
>
> Yes, but then someone would have to actually LEARN your meta markup
> language. We should have a descriptive language which allows you to
> define the syntax for your language, and it should look as much like
> plain English as possible, so that anybody could read it. We'd start off
> with an identification division, so that we could uniquely refer to
> these template languages for maximum re-use, then describe the encoding
> that the file uses so that parsers could... well... parse them.
>
> 000100 IDENTIFICATION DIVISION.
> 000200 TEMPLATE-ID: DanielDyerMarkupLanguage.
> 000300 AUTHOR: Daniel Dyer, Oliver Wong.
> 000400 ENVIRONMENT DIVISION.
> 000500 SOURCE-ENCODING: ASCII.
> 000600 LINE-ENDINGS: Unix.
> 000650 FILENAME-EXTENSION: ".ddml".
> 000700 MAIN-DESCRIPTION DIVISION.
> 000800 CASE IS: Significant.
> 000900 WHITESPACE IS: Insignificant.
> 001000 TAG-OPENING-STRING IS "[".
> 001100 TAG-CLOSING-STRING IS "]".
> 001200 TAG-END-MARKER IS "/".
> 001300 SHORT-CUT-TAGS ARE Allowed.
> 001400 ELEMENT-STRING IS "Element".
> 001500 ATTRIBUTE-STRING IS "Attribute".
> 001600 NAME-ATTRIBUTE-STRING IS "name".
> 001700 VALUE-ATTRIBUTE-STRING IS "value".
> 001800 CONTENT-STRING IS "Content".
> 001900 END-MARKUP-DESCRIPTION.
>
> There, now people (and more importantly, computers) can understand
> how to use your generic markup language! The line numbers are present so
> that copy-and-pasting code snippets in the wrong order can be detected
> and rectified. The practice is to increment them by 100s, in case you
> need to later insert a line (as I have done so; can you spot where?)
>
> I wasn't sure if you intended for your markup language to be case
> sensitive or not, so I arbitrarily guessed that it was.
>
> - Oliver

SGML already did it like this before
XML brought simplicity to SGML : there are no options like those above,
all is hard-coded in the spec ; it just remains the syntax, tags

But RefleX is not a question of syntax, it's a question of features ; I
didn't want another language that makes the stuff like others, I wanted
a language that of course has the characteristics of programming
languages, but that also could make things differents :
-allow to mix declarative-oriented sentences with imperative instructions
-allow to consider some objects like XML-friendly objects in order to
apply XPath expressions on them, and apply XUpdate-like operations to
modify them
-etc

the result is that when we designed a complete application with RefleX
which is in production today at INRIA, we did it with few tags (about
10% of the lines of codes that we should have to produce with Java),
despite the intrinsic verbosity of XML

--
Cordialement,

///
(. .)
--------ooO--(_)--Ooo--------
| Philippe Poulard |
-----------------------------
http://reflex.gforge.inria.fr/
Have the RefleX !