[Yaml-core] The Viewer concept is Flawed

[Brian I. <in...@tt...>]

On 08/09/02 18:42 +0300, Oren Ben-Kiki wrote:
> With regard to the models diagram and the need for a native model...
> 
> I don't think you can do away with mentioning the native model. After all
> the transfer method is the instruction on how to do the conversion to the
> native model; if we'd stop at the generic model...

Stop! 

Look what you said! 

This is a huge statement!

One that I've been trying to get through to Clark!

What you've implied is that you go *through* the generic model to get to the
native model. And the transfer method is how you get there. I AGREE 100%!!

The notion of the viewer is flawed! (And thus the diagram!) It assumes that
you need to get to native *before* you can get to generic. That's wrong. If
you got from syntax to native without going generic, then it was purely an
optimization. You probably didn't have any transfer methods in the syntax
either, because then you would have realized the need or at least the
implicit existence of the generic level.

The basic problem is that you (Clark) see the generic level as only a
view of the native. It definitely is from the N2Y side of things. But
what Oren implicitly says above is that native comes from generic in the
Y2N side. And that's what is missing in our diagram. You need to name a
process that is the inverse of the viewer. The generic to native piece.

The viewer calls a classes' to_yaml to get a generic node and a type uri.
What is the piece that takes a serializations generic node and type uri
and calls a classes' from_yaml to create a native node??

Here is the current flawed data flow in YNY:

  SYNTAX
    (parser)
      SERIAL
        (loader)
          NATIVE    <->   application
        (viewer)   
          GENERIC   <->   application (ypath?)
        (dumper)
      SERIAL
    (emitter)
  SYNTAX

I would propose that a "loader" has potentially two phases/modes. Generic
loading and native loading.
  - It can load serial events to a generic model. Period.
  - It can look up (from_yaml) methods based on the transfer method URIs (if
    any) and turn those nodes into native, thereby creating the native
    repesentation graph. 
NOTE: If no transfer methods exist in the serialization then in some
  languages (but not necessarily all) the generic model might be the
  same as the native model. This is what would happen in a perfect
  world, but language deficiencies simply do not make it ubiquitous. It
  is very important that the the Ruby and Python (and to some degree
  Perl) people remember that even though the generic and native
  representations of simple data might be equivalent, they are not the
  same concept. ie IMHO you need to go through generic (at least
  conceptually) to get to native, even when they are the same.

The "dumper" is the opposite. This is where your viewer logic lives.

Here is what it should be (in YNY):

  SYNTAX
    (parser)
      SERIAL
        (generic loader)    
          GENERIC
            (native loader)
              NATIVE         <-> (application)
            (native dumper)
          GENERIC
        (generic dumper)
      SERIAL
    (emitter)
  SYNTAX

See the exact symetry?

Now for YPATH, we can just omit the native load:

  SYNTAX
    (parser)
      SERIAL
        (generic loader)
          GENERIC         <-> (application - ypath)
        (generic dumper)
      SERIAL
    (emitter)
  SYNTAX

And for true streaming applications:

  SYNTAX
    (parser)
      SERIAL  <-> (application)
    (emitter)
  SYNTAX

---

But that's only YNY. What about NYN?

Here's the full roundtrip:

  NATIVE             <-> (application)
    (native dumper)
       GENERIC
         (generic dumper)
           SERIAL
             (emitter)
               SYNTAX
             (parser)
           SERIAL
         (generic loader)
       GENERIC
    (native loader)
  NATIVE             <-> (application)

This is how you'd use ypath without ever even using the serialization.

  NATIVE             <-> (application)
    (native dumper) aka viewer
       GENERIC       <-> (application - ypath)
    (native loader)
  NATIVE             <-> (application)

Cheers, Brian