Chris Sells
Marquee de Sells: Chris's insight outlet
July 11, 2003 conference

Applied XML DevCon Trip Report

Dave Winer’s Keynote:

  • Users care about you software working, not *how* it works
  • Users don’t want to be controlled
  • As developers, “we’re very impressed with the complexity that we can understand”

Don Box:

  • “No one that gets laid actually replaces the CPU in their computers anymore. And, since they don’t get laid, they can’t reproduce and natural selection will take it’s toll. Likewise, objects are not meant for field replacement.”
  • Building on abstractions means that the abstraction needs to be kept constant
  • the wire is god. schemas are relative to your needs. the same XML instance doc can be many different schemas in a pipeline
  • I missed why the abstractions in a service-oriented architecture are somehow better than those in an object-oriented architecture, except that maybe SOA abstractions are courser grained, but that can be true of OOA, too, can’t it?

Brian Jepson:

  • WAP is just another XML format to product that exposes your data to WAP-enabled devices, e.g. phones
  • Very cool to watch Brian control his presentation via his cell phone (nothing to do with XML, but very cool never the less). He was using a Mac and didn’t know if a niche OS like Windows had apps that did such things (although he did find this that might work)

Don “XML”:

  • In NJ, they teach middle school kids HTML, XML and PowerPoint (holy cow!)
  • Lots of folks asking questions, evidently interested in SVG and/or declarative-based UI models

Patrick Logan:

  • Patrick gave his talk sitting down, which didn’t help him keep the audience’s attention

Ted Neward:

  • EJB 2.1 for web services looks pretty easy
  • “Swing sucks. People are using WinForms to access J2EE web services.”
  • “Sun has drunk very deeply of the idea that web services are just CORBA.Next” aka Sun views web services as just another RPC, which means that they use rcp/encoded instead of doc/literal

David Ing:

  • Don’t take “rules” from speakers at conferences. You can be entertained by such talks, but you need to make your own decisions

KeithBa:

  • Keith starts right where I love — in the code. What better way to show the new programming model and features of WSE 2.0 than to jump right to the code? Fabulous
  • And not only did he do a fabulous job writing code to demo WSE 2.0, he did it by building a heckle application that the audience loved (and took full advantage of : ). You are a master, Keith
  • And! His application is a great example of the need for the flexible model that WSE 2.0 provides and he brings it right back around how his amusing, seemingly trivial app is really not suited for an RPC-style (which we should eschew anyway). Nice
  • And then Dave Winer jumps in to accuse him of saying that there is no such thing as asynch; there is only polling. Keith is way over the top nice about it and the audience disagrees with Dave pretty much as a whole

Speaker Panel:

  • tons of controversy; end result is that XML solves a huge number of problems and there’s no reason to do “this vs. that” because XML allows everyone to co-exist and interop (although programming may be needed to gain the latter)

Ken Levy:

  • First time showing these plans in public (off of a 2am build)
  • Showed off cool new XML editor integrated into VS.NET:
    • showed red squiggles and helpful error messages about invalid XML
    • can select text and have it wrapped in XML comments, CDATA blocks, etc.
  • showed integration of errors using DTD files, i.e. checking elements that don’t have appropriate attributes as defined by the DTD, etc.
    • will reformat your XML
    • may provide outline view for drilling into large XML docs
    • lots of intellisense based on XML/DTD/XSD tools
  • can create schema from a DTD inside of VS.NET
  • can infer schema from an XML instance
  • will enable custom mappings of XML namespaces to corresponding visual editors, e.g. showed an example of editing SVG: first view is the rendering of SVG; second view was code. If you change the code while you’re also looking at the SVG view, the SVG view is updated on the fly
  • showed interactive XSLT debugger
  • will be releasing these tools on the XML Tools page for use w/ VS.NET 2003 in the fall (tentatively)
  • send Ken Levy the things that you’d like to see in the XML tools space

Jeff Barr

  • Amazon is able to turn around small features very quickly and that’s the corporate culture
  • they spent $300M on distribution centers and $900M on technology
  • when folks were scraping the web, Amazon could have broken those apps, but realized that the folks doing the scraping were building legitimate apps with that data that was good for Amazon, so instead of crushing those folks, they tried to not change the format of the pages w/o a good reason (in spite of the added cost of supporting robot traffic)
  • to support the largest number of customers, they support rich SOAP interface and a REST interface
  • return “light” and “heavy” data, depending on how much info developers want
  • business model for users seems to be picking an unused domain, setting up a site selling something specific, e.g. power tools, then building the whole site using the data and purchasing/shipping services of the Amazon web services. Wow
  • the associate program is hugely successful for Amazon in terms of revenue generation
  • the protocol is loose so that developers have a wide range of choices of what they want to do with it, e.g. if Amazon doesn’t have all of the information being requested, they return what they have instead of failing, letting the developer decide if they want to use the info that Amazon provides or fail on their own
  • Amazon versioning: new versions get new URLs. Old versions use new code internally, but return same old data format from same old URL
  • for keeping their own data up to date, Amazon also publishes a set of services for sellers to update their data and will soon be exposing a service for sellers to create new ASINs (Amazon product IDs) for their own products
  • 80% of the requests are for raw XML/REST (with or without transformation)
  • as things get more complex, SOAP will take over

Steve Loughran:

  • bottom line: SOAP is ready for use in embedded systems (although things can get better and likely will)

Tarlochan Cheema:

  • the motivation for the sets of web services that microsoft.com is about to expose is for better communication with partners, e.g. avoiding shipping CD-ROMs around, as well as providing real programmatic interfaces for folks that are scraping data from microsoft.com, e.g. top downloads
  • the way that MS stayed at lots of 9s of reliability is with writing good code, of course, but mostly with heavy use of caching

Tim Ewald:

  • XML schema shouldn’t be used for nominal typing; it should be used for structural typing
  • different parts of an XML pipeline can have different XML schemas to check different things

Chris Dix:

  • “Everywhere is walking distance if you have the time. Steven Wright”
  • Since you can embed non-SVG data and script into SVG, these are the elements needed for stand-alone, cross-platform “intelligent” data that can provide it’s own UI

Aaron Skonnard:

  • “Scott (my code monkey) and I are still in the running for the $1M playing DevelopMentor Survivor. We kicked Don off the island first because he was the strongest and Tim second because he was the smartest.”
  • XSD isn’t enough to check real business rules
  • XPath is more flexible
  • Can write a .NET SoapExtension like this:

[WebService]
[AssertNamespaceBinding(“t”,“urn:geometry/“)]
 public class Geometry {
  [WebMethod]
  [Assert(“//t:length > //t:width”, “Length must be greater than width”)]
  [Assert(“(//t:length div //t:width) = 2”, “Length must be double the width”)]
  public double CalcArea(double length, double width){
    return length * width;
  }
}

  • Even cooler, because the constraints are part of the .NET metadata of the method, when the docs and the WSDL is generated from the Geometry web service, the constraints can be pushed in as well, making the constraints available to the developer