Formation, Introduction, and Elimination rules for specweb types?

The examples are good, but a formal operational semantics would be a
good supplement.  

Role of the type table comes as a surprise on page 7 --- is type table
new at that point?

Also, I'm not clear on the code-generation model in Fig 4.
Where do the entity and attribute tables come from?

Does this separation give opportunities for reuse?

Need a diagram of complete start-to-finish, showing separation of
concerns and opportunities for reuse.  Showing
development/prototyping/refinement cycle also good.  How does
development with specweb compare with other models of development?
Finally, a diagrammatic comparison with a traditional IDL compiler
might also be helpful.

Breadth: could you also do H/Direct?

Discussion: these are the same benefits as from literate programming,
no?

Need a better discussion of the pros and cons of scaling up.
For example:
  - simple, built-in functions for changing identifiers
    (e.g., Java name mangling --- stateful -- ucky)
  - a pure functional language for some parts of problem
  - a pure functional language for entire problem
  - an imperative language
What is it about this domain that makes the restriction to specweb
useful? 

Characterize specweb in PL terms: functions on strings?  mapping
strings over tables?  the auto-expansion is a neat trick.  An
operational semantics will help here.

Why the limited form of conditionals?  Is there a perceived benefit?
A demonstrated benefit?

What about name mangling??


Can you solve one of my favorite problems, e.g., encoding procedures
in C or Modula-3 or Java?  Or is each specweb hopelessly
language-dependent?    In more general terms, what are the dimensions
of the reuse you offer.


*Why* must a user edit generated code skeletons?  This seems to be a
common problem --- help your reader understand it.

It's not clear to me why the representation of tables is that
important.

The appendix is too important to leave in an appendix.

How hard would it be to generate ordinals using specweb.
What part of the problem is it solving, really?

The weaving of the appendix is not very pleasant to read IMO --- have
you considered using a font to distinguish chunks?

Static instance stuff could be clearer.  In fact, it would help to
show a pseudocode template of the Java you wish to generate, or
perhaps simply the generated Java (with suitable ellipses).


Suggestion: DSL conference, if any.