[rtcweb] New language (was: ... WebRTC JS Object API Model)

[Martin Thomson <[e-mail]>]

On 1 July 2013 11:17, Ted Hardie <[e-mail]> wrote:
> Honestly, I have read it and I don't see how you avoid mandating some
> standard
> interface between the JS and browser.  That needn't be SDP, but if it is
> causing the
> two sides to negotiate candidate transports and emit RTP, it's going to be
> hard going
> to avoid it being SDPNG.

This is an important argument, but it's only correct up to a point.
And that is misleading.

SDP does a lot of things that an API can do in far simpler ways.  Take
BUNDLE, or the plan A/B/No question.  We all know what these need to
do, but we are encumbered by existing SDP - which is no single thing -
in trying to reach a conclusion.

Interconnectedness makes SDP hard.  Harder than it needs to be.  The
main advantages of a new form of expression come from its ability to
isolate problems. For instance, separating transport establishment was
clearly a big win for Jingle in terms of flexibility, simplicity,
capabilities.

But those examples speak directly to your point.  A new "language"
might be unencumbered in a way that might make addressing these
problems easier, it might even be more capable, but it is still just a
new way of saying the same old thing.

Offer/answer is the problem.  It's a contrivance that can be chosen or
rejected depending on how you plan to interact with the API.  That
embeds a negotiation engine into the browser, along with all the
machinery for how to negotiate everything that SDP expresses.

Negotiation is an extra, a feature that the IETF decided to add to the
API to make it "easier to use".  That wouldn't be a problem if it
weren't mandatory, but it's the only way to do anything.  (In
contrast, CU-RTC-Web provides a negotiation feature, but it's an
optional extra.)

So SDP truly becomes a problem when coupled to offer/answer.  The way
that features interact become a problem for standardization, not
because they interact with each other - interaction problems are what
engineers are for - but because they are negotiated.

And it's not the SDP negotiation that is the worst: it's the
negotiation of what it means.  We all know what it means, but I'm
certain no two people "know" SDP the same way.  That means another
sort of negotiation.  And those negotiations require that those
engineers be sent to places like the IETF to argue endlessly, or play
at politics.

--Martin