I was thinking of this myself and perhaps its a profound misunderstanding ....
The correlation between when there is little tolerance for errors vs when specs are needed vs change .
In a pipeline say like
Outside World 1 -> my pipeline -> step a -> step b -> step c -> Outside World 2
Inside My World (step a, step b etc) there may be very little tolerance for errors, because its a tightly controlled
situation and because the same person or group is maintaining the inputs and outputs. It's not worth the effort and performance and development costs to enforce
data integrity at every step.
Its also a place where changes can and need to happen frequently.
This is where I would NOT bother with a schema. Change should happen as needed and all parties would tend
to be closely communicating. Less validation would be done, more expectation that data is already in the format needed,
and produce exactly what the next step wants.
Outside My World (say the Big Input and Big Output) is where I would want schemas ...
say for example, HL7 In, and HTML Out.
These are interfaces which I dont want to change often, where the parties involved may not be communicating closely,
where frequent change is a generally detrimental and a tight schema has the highest value to help make the process work
with the least risk.
I am not at all sure if this is entirely opposite of what Simon is saying or exactly the same thing but stated differently ...
----------------------------------------
David A. Lee
dlee@calldei.com
http://www.xmlsh.org
From: Peter Hunsberger [mailto:peter.hunsberger@gmail.com]
Sent: Thursday, October 17, 2013 6:36 PM
To: Simon St.Laurent
Cc: xml-dev@lists.xml.org
Subject: Re: [xml-dev] Transformative Programming: Flow-based, functional, and more
I'll buy into your view on REST, maybe a better fit is something like Web Sockets? However, I can't agree with you in regards to tighter specs
inside applications and looser between them. Are you suggesting that (for example) a Java method that has a single String as it's input and output needs a full XSD or some other more formal spec? I suspect you're indulging in a bit of hyperbole in that,
flexibility between applications in what they can accept might simplify the world, but you know as well as anyone that not everything can be mapped to name value pairs or tuples and left at that?
On Wed, Oct 16, 2013 at 4:32 PM, Simon St.Laurent <simonstl@simonstl.com> wrote:
On 10/16/13 4:23 PM, Peter Hunsberger wrote:
Seems pretty coherent so far. I think maybe part of your discomfort
with REST in this context is that it requires standardization of the
data interchanged across the boundaries?
Actually, part of my fondness for REST lies in its not requiring data standardization. That's been a part of what people (mistakenly IMHO) do with REST, but it's not central to the approach.
The problem is more that REST is about manipulating resources than about flow through a pipeline. I know REST is flexible enough to handle most everything, but I'm not convinced it's actually a natural fit.
If so, you may want to explore
to what extent that is true since REST is an obvious target, even with
the single Enterprise, at least at the higher levels of granularity (as
evidenced by Amazon WS for example). That could still give you a
consistent story (and an interesting one in and of itself): the more
granular you go the less formal the needs of the interchange format.
So, between Enterprises you (well at least some people) might even
allow for XSD and their ilk, but within an application you get closer to
Unix pipes. etc.
Actually, I'm pretty sure at this point that the computing world needs the opposite of that. Tighter specifications inside of applications, looser connections between them (and between organizations).
Thanks,
