[exprla-devel] RE: [XPL] Instruction Set Architecture in XML?

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

--- In xpl-dev@y..., "Richard Anthony Hein" <935551@i...> wrote:

  -----Original Message-----
  From: root@m... [mailto:root@m...]On
Behalf Of Jonathan Burns
  Sent: June 29, 2000 9:35 AM
  To: xpl@e...
  Subject: Re: [XPL] Instruction Set Architecture in XML?
  Richard ... lad ... are you all right?
  [Richard Anthony Hein]
  I was just really bored, sorry for wasting bandwidth everyone.
  You give the strongest impression of someone as disoriented with 
machine
code
  as I am with the Hytime Spec ( yes! the dreaded 10744, and thank 
you for
setting
  me onto the Groves path ).
  [Richard Anthony Hein]

  You're welcome!  ;-)

  Listen, did you get my long post a few days ago on what and when to
compile in XPL?
  [Richard Anthony Hein]

  Yes.


  I did my best to explain that time and memory savings from 
compiling XML
processing
  were likely to be lost in the larger inefficiencies of the system, 
unless
heroic
  measures were taken to optimize the latter.
  [Richard Anthony Hein]

  I thought this concept would be the heroic measure.  Nevertheless, 
I see
your point.  Doesn't change the fact that there are all these 
different
machines, and here we are writing a programming language.  It has to 
have
some kind of VM in order to be able to read the XPL code and process 
it.  Or
are we going to use Java to process the XPL and then send it to the 
VM?  If
that's the case, you better let me know; I have to understand a lot 
more
about Java I/O stuff before I can even think about what it means.  I 
really
want to know, the PROCESS - what is the chain of events when you 
execute an
XPL program?  I guess we don't have it yet, do we?

  Despite this, I have a sense that taking XSLT processing down to 
the metal
might
  yield benefits. Whether it's so, would depend on the profile of the
processing.
  If we could demonstrate that there are critical loops, in which the 
same
thing
  happens to a whole lot of data, and if these loops typically take 
up a lot
of
  the time it takes to do useful things, then yes.
  [Richard Anthony Hein]

  In a sense, an optimizing compiler, that decides what those 
critical loops
may be, compiles them, but leaves the rest in the information-rich 
form of
XSLT?

  That's not quite what you were talking about, though.

  You were talking about making up descriptions of ISAs, in XML, and 
using
these
  to generate the XPL compiler for each architecture.
  [Richard Anthony Hein]

  Yes.  On the fly.  Kind of a metacompiler - a compiler that takes
instruction sets schemas as input and outputs a compiler.

  Not a stupid idea. But consider this.
  [Richard Anthony Hein]

  It's not?


  We're talking about compiling the XPL processing - i.e. the 
operations on
the
  parsed data - the semantic stuff - the actual nodes and attributes. 
In
other
  words, the operational semantics.
  [Richard Anthony Hein]

  Okay ...

  So what defines the operational semantics?

  Well, the XPL specification that we use. Which could be
XPath/XSLT/XPointer/Xcetera.
  That's what we want to map to the target ISA.

  Big job, eh? Lots of operations in XPath - lots of options for
pattern-matching,
  tree-walking, etc. And more of them in XSLT.

  OR, the base specification could be a set of Architectural Forms - 
i.e.
property sets.
  And the XPath/XPointer/XSLT operations could be written, once and 
for all
or nearly,
  in terms of them.
  [Richard Anthony Hein]

  Yes.  I think so.

  Then what we would want is a mapping of a sufficient set of 
property set
operations
  into the target ISA - plus a mapping of the relatively simple 
programming
constructions
  which express each X-type operation in terms of them.
  [Richard Anthony Hein] '

  Yes, and that semantics of patterns thing that we discussed earlier 
for
XSLT (have you seen it?  I think it's succinct), and XPath is 
available.  We
need one for XLink and the others, and then we can normalize it, if
possible.  Then what we have is pretty simple description of all 
the 'X'
technologies in the same format.  Map that to the instruction set, 
and the
other way to the actual 'X' technology, like XSLTs syntax.  The
compiler/parser whatever it is going to be, simply transforms between 
them.
Do I understand yet?

  Little job.

  And that is one reason why I am intensely interested in the Groves 
stuff,
the property
  sets. I have not yet discovered any material to the effect: X-
whatever
Implemented In
  Groves.
  [Richard Anthony Hein]

  I'll search for it this afternoon.

  If it hasn't been done, it should be. I suspect I could do it, if I 
made
it The Priority.
  [Richard Anthony Hein]

  If you want to, go for it.  Maybe wait until we've searched for 
prior
work, but if we don't find anything, then I guess I'll be The 
Priority for
you Jonathan, if you like.  Anyone else care to make it The Priority 
as
well?  I will do whatever I can to help.  I figure I can do up some 
of it,
after I look at the way you go about doing it.


  IT WOULD ELIMINATE A VERITABLE ARMY OF BUGS FROM XPL AT THE OUTSET.
  [Richard Anthony Hein]

  That's certainly a benefit.

  Property Set Architecture -> Instruction Set Architecture

  is where I think the value lies.

  [Richard Anthony Hein]

  Ok, so then this is saying to me, that we could really use the 
property
sets of the 'X' techs to map to the ISA, and have ourselves a 
programming
language - once we map all those property sets into XPL syntax, which 
uses
XSLT and other stuff, and fill in all the holes that the property 
sets have
with XPL specific property sets and semantics.  There is no point in
deciding what XPL can do before we know what all the other techs that 
are
recommendations can already do, is there?  SO, after figuring that 
out, we
can fill the holes, and make a way to merge them all together in XPL.

  Do I understand?  Grade me Jonathan, you must be used to it!  :-)

  Jonathan

  "Ask anything!"  he muttered, as he spat
  a small blue insect whirring into the gauze.
  "I would advise stilts for the quagmire
  Camels for the snowy hills
  And any survivors
  Their debts I will certainly pay.
  There's always a way."

  - The Incredible String Band
  [Richard Anthony Hein]

  "... it's a hell of a start,
  it can be made into a monster
  if we all pull together as a team!"

  - Pink Floyd - Have a Cigar

  Richard A. Hein






----------------------------------------------------------------------
------
--



----------------------------------------------------------------------
------
--
  To unsubscribe from this group, send an email to:
  xpl-unsubscribe@o...
--- End forwarded message ---