XML challenges to programming language design

XSLT and JSP use XML syntax for both logic and creating XML. (Verbose, hard-to-read.)
XQuery uses functional syntax for logic, and XML syntax for element construction. (Less integrated.)
In the Lisp world, we can use S-expressions (SXML). (No dynamic validation or static typing.)
LAML maps each HTML tag to a mirror function with the same name.
Calling a mirror function generates a node object.

Short-hand syntax for defining new constructors functions:

(define-element html (head body))
(define-element body any) ;; if lazy

XML namespaces are similar to Common Lisp packages.
Even uses same syntax: prefix:local-name
However, namespace is just a URL string.
Namespace declarations map prefix to a URL.
Namespace declarations can be lexically nested
(hence must be done after read-time).

(define-namespace html "some-unique-string")
(html:html (html:body (html:p "Hello")))

(html:a href: "http://gnu.org/" "GNU")

Non-nesting sequences handle common case easier:
list, cons, append are combined.
Non-nesting sequences may be easier for beginners.
E.g. a char and a one-char string are the same.
Symmetry between parameter list and result sequence.
Integrates expressions and statements.

A Scheme <body> is one or more expresions.
Its value is that the of last expression.
Instead, make value of <body> be concatenation of values of sub-expressions.
Define define, set! etc to return zero values.
If we really need to discard result, use explicit discard.

(define x
  (let r ((i 0)) ;; R5RS "named let"
    (+ 100 i)
    (if (< i 5)
      (r (+ i 1)))
    i))

evaluates to:

100 101 102 103 104 105 5 4 3 2 1 0

Mozilla's XUL and Microsoft's XAML let you lay out GUI applications using XML to describe nested widgets.
Easy to use, less verbose than Java/C#.
Integrates poorly with event handlers, awkward repetition.
Attributes and children are literal, not calculated.
Element constructors have same benefits and solve problems.

(do ((i 1 (+ i 1)))
    ((> i 10))
  (button
     label: (number->string i)
     onpress: (lambda () (handle-digit i))))

Nice to use parentheses for grouping rather than application, as in ML etc.
Also nice to use juxtaposition for sequence concatenation; avoid noise syntax in input not in output.

fun1 a b c
       fun2 d e
       fun3 f

-->

(fun1 a (b c)
        (fun2 d e)
        (fun3 f))

Per Bothner