Re: Why Binding Scripting in Style Layer Conflates Semantics

Note I will be traveling in islands/mountains of SE Asia for 2 - 3 weeks,
probably starting today, so this may be my last post for a while.  When
when I get back, hoping to read from you all a wealth of revolutionary
insights, not acrimonious debate for sake of proving who is "right" on
every little tidbit.  The key question is whether having in markup <select
type="country"> is more useful than <select>??  That is what Semantic Web
asks you?  Nice if we could stick to that key question without muddling it
with irrelevant tidbits.  Noise is an effective technique to kill the
messange, but in meantime others are moving ahead of us.

Mark Birbeck wrote:
"...operates in terms of pre-defined objects--XAML is in this category..."

I have already shown that XAML allows object sub-classing, which means we
can add functionality to <select>, e.g. <select x:Class="mapselect">
without breaking legacy UA.

" get accessible, cross-platform applications you should
abstract out the task, not the tool..."

Agreed.  XAML supports sub-classing.

"...Shelby is making some interesting points, I feel it is *he* that has
not read Lachlan's post closely enough..."

Trust me I completely understood Lachlan's and your points.  They have not
changed my fundamental point, as expressed in opening paragraph of this
post.  Irrelevant tidbit, I've been doing OO programming _commercially_
for 19 years (40 years old).

"...the only interfaces that are of interest are the 'select
an item from a list' interfaces...this does not mean that the widget that
does the mapping needs to 'inherit' from <select />..."

Incorrect.  You are forgetting the semantic issue, which I re-summarized
in the opening paragraph of this post.  The markup layer needs to know
that you are sub-classing the <select> into a <select type="country">, so
that consumers (UAs, crawlers, other scripts, etc) that access the markup
layer will know this additional semantic information (that they items are

"...If you want to change it to something else (a list of cities instead
of countries, for example) you either re-compile, or you edit your XAML,
but either way you have to change the *application*..."

Not at all.  Analgous to editing your XBL script, you edit your markup and
your code-behind .Net class, and then when your Windows (or open source
Mono) browser hits the markup, it loads your .Net class.

"...but instead saying 'at this point I want the user to be able to input
a value, but how they input the value depends on what the type of the data

We can make a .Net class and markup to handle that, analgously to your
XForms example.  The beauty of XAML is it is fully generalized without
conflating the style and markup layers.  Yes you are correct about the
importance of how to bind.  And that is why we must bind at the correct

But don't confuse this with limiting our binding possibilities.  If you
want selectors and cascade, then make a CSS-like binding syntax for the
markup layer (not at style layer, not conflated with style declarations),
which doesn't obscure semantics of extension, e.g.

select[type="country"] { mapselect inherits from select }

But if you allow:

select { mapselect inherits from select }

Then be full aware of the complexity overhead you are putting on semantic

There are some very important design justifications for the XAML syntax. 
Read the Microsoft programmer blogs I linked to for the reasons they
dropped the CSS-like syntax.  And I don't think even considered the
semantic crawler angle (at least they don't talk about it).

Mark Birbeck, I apologize I didn't have time to look at your screen shots
or read your blogs.  Maybe in near future.  Thanks for further
illuminating the issues.

Andrew Fedoniouk wrote:
"...From practical implementation point of view having defined
 x:Class="MyNamespace.MapSelect" is not enough as this
does not tell me what is the superclass of MyNamespace.MapSelect..."

Incorrect.  <select x:Class="mapselect"> declares that mapselect is a
subclass of select.

As for how to get the super class of select (if there is one), then can be
done via .Net CLR (language independent layer) using reflection.  In my
view, .Net CLR replaces the DOM in .Net's model of new world wide web.  It
is much more powerful.

The implications are ubiquitious.  I think we need to populate the thread
I started, "Future of CSS in Semantic Web?".  Thanks.


Kind Regards,
Shelby Moore

Received on Friday, 25 November 2005 02:40:18 UTC