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
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”)]
publicdouble 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
Here. I'm posting this using the wireless access from the room where the Applied XML Developer's Conference will be going on tomorrow (testing from the back to make sure it works). If I wanted to, I could plug into the readily available power as well. Very spiffy.
If you'd like to participate in the conference, head over to the conference home page for the link to the message board and post to your heart's content.
Here. With Dave Winer on the side of RSS [1]giving the Day 1 Keynote and Sam Ruby on the side of Echo [2] speaking the very next day, the Applied XML Developer's Conference is bound to be a rip-roaring good time. I can't wait. : )
[1] http://intertwingly.net/blog/
[2] http://www.scripting.com
