exprla-devel

[exprla-devel] Re: [XPL] Is the project alive?

[reid_spencer <ras...@re...>]

--- In xpl-dev@y..., Jonathan Burns <saski@w...> wrote:
Alexander Gutman wrote:

>  Hello, friends.
>
> I have just subscribed to the group and read all
> the messages posted here since the creation of the group.
> As a result, the question arises: Is the project alive?
>
> I do not see any lists of tags except some very short raw examples.
> What is the current state of the project?
> The group exists for three months already,
> but the project does not seem to be far from just an idea.
>
> Hope I have missed something important. :-)
>
> Thanks.
>

Hi Alexander, and thanks taking the trouble to read through
the archive. No, you haven't missed anything so far.

I'm not speaking for the mailing-list here, just myself.
But I've been involved since fairly early, and I certainly
hope we can keep up the pace.

One thing to keep in mind, is that interest groups start from
diverse points. As far as I can tell, the majority of open-
source projects begin as splinters of existing efforts, with
pretty clear mandates - often specifications which were
formaulated within the earlier effort.

The XPL project seems to have started independently and small,
with a handful of active participants. So far, we're really
still at the stage of getting to know each other and our skills.
Quite a few ideas have been thrown around, but it may be months
yet before we have a prototype which we can throw away, before
buckling down to write a solid specification.

It looks as if there are just four at present who are really
keen. I for one, am going to have to take XPL at the pace
I can, and it's pointless to work from expectations, e.g. that
three months is too slow.

Let me lay out a few points, on which the group would probably
agree:

1.  To date, XML has been applied to everything except programs.
More accurately, XML has been primarily applied to interfaces
or formats,, which is where it's immediately needed. Programming
is tacked on as callbacks from document parsing - mainly in
Java and Javascript. From the point of view of the existing
developments, it would be a mistake to hardwire XML-based
implementations together with XML interfaces.

2. There are good reasons to explore the resemblance between
programming languages and XML. One is that procedural code
has a hierarchic structure. Another is that both XML documents
and programming languages are defined by grammars.

3. We want to develop XPL as a procedural language, because that's
what we have in common. Me, I see the real benefits coming from
functional language developments - but I think it would be quite
counterproductive to insist on this at the outset.

4. We know that the modularity principle for XPL is going to
derive from namespaces or from composition of grammars, or both.
Just which option will turn out most fruitful, is something
we'll find out as we move along.

5. This is a real opportunity for lateral thinking. IMHO, if we
follow strictly in the footsteps of say Tcl or Javascript, we'll
never make a novel contribution. But at the same time, we need
to get some leverage from these demonstrated technologies. Also
IMHO, this is an opportunity to stand back from some of the
conventional wisdom of programming; and to re-open the deep
issues of why programs are supposed to be programs, and data
data.

6. It's up to us active members to show what the value of an
XPL effort is. We might do that by creating a working prototype;
or by setting out the theoretical issues clearly and accurately.

7. The journey of a thousand miles begins with a single step.

In the end, all I can say is: stay tuned. Or maybe, mail in
your thoughts about what an XPL should be.

See ya

Jonathan

Quality accumulates, rubbish just piles up.
--- End forwarded message ---

[exprla-devel] Re: [XPL] Is the project alive?

[reid_spencer <ras...@re...>]

--- In xpl-dev@y..., Steve Ball <steve.ball@z...> wrote:
Jonathan Burns wrote:
[...snip...]
> 3. We want to develop XPL as a procedural language, because that's
> what we have in common. Me, I see the real benefits coming from
> functional language developments - but I think it would be quite
> counterproductive to insist on this at the outset.
[...snip...]
> 5. This is a real opportunity for lateral thinking. IMHO, if we
> follow strictly in the footsteps of say Tcl or Javascript, we'll
> never make a novel contribution. But at the same time, we need
> to get some leverage from these demonstrated technologies. Also
> IMHO, this is an opportunity to stand back from some of the
> conventional wisdom of programming; and to re-open the deep
> issues of why programs are supposed to be programs, and data
> data.

I posted to comp.lang.tcl a few days ago on XPL, so funny you
should mention Tcl.

Lateral thinking is definitely required here.  Why reinvent those
scripting languages?  XPL needs to find a niche and then exploit it.
The obvious niche is the processing of XML document data.
Functional programming feels more right to me.

Now, an XML based language is going to be quite verbose.  That's the
nature of XML.  For that reason it is unlikely that people are 
going to type it in interactively on a command-line, like Tcl.
It then follows that XPL will be a compiled language.  Is that
reasonable logic?

There are several reasons why a XML based language is appealing.
One is that all of the tools being developing for authoring,
styling and otherwise manipulating XML documents become immediately
useful to XPL programming.  But are they really useful?
XSL could be used to style a XPL program.  XSL could also be used to
generate a XPL program, but would that happen in real life?
Programs tend to be written, rather than generated, or could XSL
be used as a macro facility?

At the Tcl2K conference I spoke with Dave Beazley about SWIG version 
2,
and it is using XML in interesting ways.  Could be some overlap there.

I would say "HTHs", but the above is more of a rant/ramble...
so I'll just say "Enjoy" ;-)

Steve Ball

-- 
Steve Ball            |   Swish XML Editor    | Training & Seminars
Zveno Pty Ltd         |   Web Tcl Complete    |      XML XSL
http://www.zveno.com/ |    TclXML TclDOM      | Tcl, Web Development
Steve.Ball@z...  +-----------------------+---------------------
Ph. +61 2 6242 4099   | Mobile (0413) 594 462 | Fax +61 2 6242 4099
--- End forwarded message ---

[exprla-devel] Re: [XPL] Is the project alive?

[reid_spencer <ras...@re...>]

--- In xpl-dev@y..., Jonathan Burns <saski@w...> wrote:
Steve Ball wrote:

> Now, an XML based language is going to be quite verbose.  That's the
> nature of XML.  For that reason it is unlikely that people are
> going to type it in interactively on a command-line, like Tcl.
> It then follows that XPL will be a compiled language.  Is that
> reasonable logic?
>

"Compiled" is getting to be a somewhat fuzzy word in this context.

Traditional compilers (1) translate high-level source to a parse-tree
structure, and (2) address a machine architecture (i386, PPC, 
JVM, ...)
to translate parse-tree traversal into efficient machine code.

For the verbosity issue, we're looking at (1). Standard high-level
languages already give us concise and powerful expression syntaxes.
The question for XPL is, can we smoothly and accurately translate
from these syntaxes to verbose XPL, and back again? IF so, then in
a sense, high-level languages are just styles of one another, and
something like XLST might work as a translator. The REAL technology
for HLL -> XPL is BNF grammars, meaning the ancient Yacc, or 
reasonable
facsimile, as used in hundreds of compiler parsers.

The other compilation issue, (2) is execution speed - to which we must
these days add machine-code size, for swift transmission of executable
code. I reckon that we get most of this, if we just tokenize the XPL
text - a straightforward task.


> There are several reasons why a XML based language is appealing.
> One is that all of the tools being developing for authoring,
> styling and otherwise manipulating XML documents become immediately
> useful to XPL programming.  But are they really useful?

Oh, how I need the study time, to determine the precise answer!

My impression is that almost every XML tool being developed is 
relevant
-
XPath, XLink, the DOM, XSLT, and more. Put them together, and they may
give an enormous initial boost to the XPL effort.

My XPL slogan:

    What can we do WITH an XML document?
    What can we do TO an XML document?

> XSL could be used to style a XPL program.  XSL could also be used to
> generate a XPL program, but would that happen in real life?
>

Alexander Gutman and Richard Hein are interested in this one, and
they'repretty affirmative.

I just want to say:

    Anything that can take high-level syntax and produce a parse-tree
    can produce it in XML text as easily as it can in linked data
    structures.

So, Yes.

> Programs tend to be written, rather than generated, or could XSL
> be used as a macro facility?
>

Yes. But in our enthusiasm for the new tools, let us not neglect
yearsand years of traditional parsing experience. Don't dis the yacc.

This, by the way, is why I like DTDs. Pure grammar.

The question, "DTDs or Schemas?" is one we must trhoroughly explore;
like another one, "DTDs or Namespaces?"  They may both turn out to be
religious, but they must certainly both be addressed in a Real White
paper.

> At the Tcl2K conference I spoke with Dave Beazley about SWIG version
> 2,
> and it is using XML in interesting ways.  Could be some overlap 
there.
>
>

Well, I checked out Zveno last night, and I'm impressed. It pleases
megreatly to have this resource in Australia.

Jonathan

"These are not 'globals', dear boy, these are Total Access Variables.
And they're the coming thing."

"Unleash the Power!"
--- End forwarded message ---