RE: [xml-dev] Markup language designers - How does one find or determine

["Len Bullard" <cbullard@hiwaay.net>]

Eve did write a good book.  There isn't a best approach or a single all
embracing theory.   In looking at existing DTDs and schemas, the namespace
is shaped by the number of users and perspectives or functions as selected
by the colleting authority.  So when you say "functional" you are also
saying 'views' and if they are combined, names that don't collide and that
gets warped fast.

A fairly good one to study is the mil production.dtd (40051C) for an example
that grew over time, has a large but functionally big picture limited set of
users, and tries to sensibly incorporate all of their functional
applications.  As a result, it's a beast.  Eliminate the faux modularity of
the parameter entities (useful to the maintainers but not core) and once
expanded, count the branches starting at the top.  That's a rough complexity
metric.  Work out which ones are there because they actually are choices
about real content and which ones are their to suit systems (eg, the paper
versus the ietms and frame systems).  Of those branches (shoulda been
different DTDs), what are the membership frequencies of each leaf element
type, attribute group (here you can look at the parameter entities and see
what the designer thought useful to group by name), and finally the
singletons that only show up in one element.

Now of those which meet your definition for basic or core?  It isn't as
simple as one would wish it to be because the collecting authority may
subsume multiple overlapping functional user groups.

Most long lived languages are overloaded with growth rings of past
initiatives and future goals as yet unmet as well as special cases of
limited applicability that are crushed in there because of turf battles.

len

-----Original Message-----
From: Costello, Roger L. [mailto:costello@mitre.org] 
Sent: Saturday, July 30, 2011 8:48 AM
To: xml-dev@lists.xml.org
Subject: [xml-dev] Markup language designers - How does one find or
determine the basic/core set of markup combinators?

Hi Folks,

When designing a new markup language, how does one find or determine the
basic/core markup items?

Consider:

In mathematics one identifies a small, simple set of axioms that everyone
can agree are obviously true. For example, one commonly used axiom is the
commutative law: a + b = b + a. The axioms are combined in various ways to
create new truths (i.e., theorems). My mathematician friend tells me that
the universe of truths (theorems) that can be derived depends on the
starting axioms.

In functional programming one identifies a small, simple set of combinators
(functions) that are combined in various ways to create new combinators.

Simon Peyton Jones identifies these characteristics of basic/core
combinators [1]:
-      Each combinator is independently useful.
-      Each embodies a distinct piece of functionality. This simplifies
their semantics and enriches the algebra of composition.

Simon Peyton Jones says this about the process of identifying a set of
basic/core combinators: "The [basic/core] combinators ... are the result of
an extended, iterative process of refinement, leading to an interlocking set
of decisions -- programming language designers will be quite familiar with
this process."

In designing a markup language one identifies a set of elements and
attributes that are to be combined in various ways. Consider one markup
language -- XML Schema. It contains element and attribute declarations and
simpleType and complexType definitions that are combined in various ways to
create definitions of valid XML instances. Consider another markup language
-- RELAX NG. It contains a different set of basic/core elements and
attributes. How did the creators of XML Schema and RELAX NG come up with
their basic/core elements and attributes? When *you* create a new markup
language, how do *you* come up with the basic/core elements and attributes? 

Markup language designers -- How do you find or determine the basic/core set
of markup combinators?

Finding the "right" set of basic/core axioms or combinators or markup is
important. The set determines the universe of things that can be defined,
the ease with which things can be defined; and how readily it is adopted.

Do you know a good book or article that describes the *process* of finding
or determining the basic/core items in a newly-to-be-created markup language
(or the basic/core combinators to be created for a functional program)?

/Roger

[1]
http://www.xfront.com/The-Fun-of-Programming/Chapter6/How-to-write-a-financi
al-contract.pptx 

_______________________________________________________________________

XML-DEV is a publicly archived, unmoderated list hosted by OASIS
to support XML implementation and development. To minimize
spam in the archives, you must subscribe before posting.

[Un]Subscribe/change address: http://www.oasis-open.org/mlmanage/
Or unsubscribe: xml-dev-unsubscribe@lists.xml.org
subscribe: xml-dev-subscribe@lists.xml.org
List archive: http://lists.xml.org/archives/xml-dev/
List Guidelines: http://www.oasis-open.org/maillists/guidelines.php