Web Services

May 05, 2006

SOA Governance Panel Reprise

We’ll be doing a reprise of the SOA governance panel at the SOA Executive Forum on May 16th in New York. The panelists will be:

• Ed Vazquez of Sprint-Nextel. Ed’s the Group Manager of the Web Service Integrations & SOA.
• Jeff Schneider of MomentumSI
• Johannes Viegener of Software AG. Johannes is Vice President of the R&D Crossvision Suite
• Michael Hill of HP. Mike is the Global Director for Enterprise Architecture & Governance

This should be a great panel. Ed and Jeff were on the panel in March and did a bang up job. I’ve heard good things about both Johannes and Mike.

Like last time, the panel will be run with a strict moratorium on PowerPoint slides. I’ll spend 3-5 minutes introducing the subject, give each panelist 2-3 minutes to introduce themselves, and then we’ll launch into questions. I’ll have some prepared and also take audience questions. Here are some of the questions that we used last time to get things moving:

• Why is governance important?
• How does your company govern SOA?
• What big mistake did you make early on that convinced you that you needed to govern your SOA efforts?
• What role do policies play in governing SOA? What policies do you have?
• How do you distinguish between design-time, deploy-time, and run-time policies? Do you treat them differently in the governance process?
• Do you have a center of excellence (COE)? What role does it play? How does it work?
• How are governance and architecture related?
• Have you encountered resistance to SOA governance in your organization? How do you overcome it?
• How do you enforce policies? Who enforces policy?
• What process do you use for feeding back information from enforcement and taking corrective action?
• Is any of your policy enforcement automated (WS-I checks for example)? How do you do it?
• What role do registries play in your governance efforts?
• What role do Web services management systems play in your governance efforts?
• Do you use SLAs or other contract devices between providers and consumers? How are they managed?

The audience responded very well last time and asked quite a few questions themselves. If you’ve got other questions about SOA governance that you think ought to be addressed, please leave a comment.

02:12 PM | Comments (2) | Recommend This | Print This

May 03, 2006

Wiki Wednesday

After the day was over at IIW, Eugene Kim was headed down to SocialText to speak at Wiki Wednesday, so some of us tagged along. The evening was nice enough that we moved it outside. A very informal and nice conversation.

Eugene was being controversial and said that recent improvements to wikis are missing the point. Wikis are transformational tools for communities. They are neutral space. So what features are needed and central to the notion of a wiki?

Yet wikis need single sign on. Lightweight SSO solutions are viable. If wikis are supposed to be about community, then you ought to be able to get one them easily. Wikipedia is multiple wikis. Every single one requires that you create a new user. This breaks community because you can’t carry identity from one place to another.

Reputation is another issue for wikis. The number theme at the last wiki conference was reputation. Wiki people don’t know what reputation means. Wikis already have reputation, but we’re not acknowledging it or branding it. Wikipedia articles, for example, have discussion pages, authors, author expertise, number of edits, and so on. People should be able to see these. More transparent metrics are important.

A simple thing you could do is to “age” pages so that page color changes the older and staler a page is. Using a visual metaphor gives information without making an explicit reputation claim.

I made the point that reputation is “my story about you.” Reputation is not a community thing. Communities tend to arrive at similar reputation judgments because of webs of trust. The key is to expose facts so that reputation can be computed based on those facts.

Wikis shouldn’t look too good or too finished. When someone sees a document that looks finished, they assume that someone owns it or that there’s no point making comments.

The second, and most important characteristic of wikis is that wikis are about language—specifically shared language. Shared language is the number on thing in building collaborative communities. “Link as you think.” Referring to pages by name means you’ve for to think about page names (thinking about language). You might be using words differently than someone else. This can relate in namespace clash—a good think in wikis. This drives nomenclature convergence.

This affordance that wiki page links have to encourages name space clash is similar for tags. Tags create clashes and serendipitous connections. If you do a page index on any wiki, you’re seeing the vocabulary of that community. The default for this listing is an alphabetical list. We should us tag clouds based on backlinks to words as a better visual metaphor for nomenclature. Wiki tags should not just show pages so tagged, but also wiki words.

Nomenclature isn’t an exercise where you can get everyone together for a few meetings before the project starts and build a taxonomy. Any tool built on a wiki structure will get “link as you think” as a matter of course. That doesn’t need to be. There’s no reason you can’t have a “link as you think” feature in forums, email, blogs, and so on. Link as you think encourages convergence around ideas.

08:19 PM | Comments (0) | Recommend This | Print This

April 24, 2006

LDDI Replaces UDDI

Dave Linthicum says:

With lack of interest in UDDI there seems to be a need for another directory standard to come up and take its place.

From Will there Ever Be a Common Directory Standard? | By Dave Linthicum
Referenced Mon Apr 24 2006 16:48:55 GMT-0600 (MDT)

I propose LDDI, a system built using RESTful techniques and microformats that creates a human and machine readable directory for Web services.

04:48 PM | Comments (0) | Recommend This | Print This

April 18, 2006

LDDI: Microformats for SOA Registries

My student, Tom Warne, has been working on a project we call LDDI for the last 9 months or so. LDDI is short for Lightweight Description, Discovery, and Integration. LDDI is briefly described in the short paper LDDI: Microformats for SOA Registries.

LDDI Usage Scenario (click to enlarge)

LDDI uses microformats and HTTP to achieve a usable registry service for SOA. The idea is quite simple, but also fairly powerful since it makes a human readable Web site into a machine readable registry service. Because it’s based on XHTML and HTTP, it is browser and search engine friendly.

Tom has developed the microformats for WSDL and WSIL and built tools that demonstrate how they can be indexed, searched, discovered, and used within existing Web services frameworks like .Net and Java. His thesis will be done in the next few weeks. I hope to have a paper somewhere in between the 3 page document I linked above and the 100 page thesis in size in the near future and links to tools so that interested parties can try it for themselves.

Interestingly, Tom met some resistance to this idea from people in the microformats and REST communities. I guess the feeling was that “pure” technologies were being used in the service of something that was “wrong” or maybe even “evil.” My feelings are more pragmatic than that. There are lots of smaller organizations that can’t afford a UDDI registry and yet will need a way to record SOAP-based services. Why not use RESTful techniques in service of that very real need?

What’s more, there’s nothing in what Tom’s done that is limited to SOAP-based services. This work also demonstrates that a functional registry of RESTful services could be developed as well—if there were a description language for RESTful services.

At any rate, I think Tom did a great job of demonstrating what can be done. There is much to be done.

• There are additional microformats that could be profitably included in the system.
• The whole idea of searching microformatted data is open.
• Registries are morphing into repositories, storing more and more metadata about services. What does this mean in the microformatted space?
• The entire system needs to be made “releasable” and usable so that other’s can use and add to it.

If you’re interested in seeing any of this work move forward, there are students who could use your support. Supporting a student is a sure fire way to see your agenda move forward for a small investment.

I’ll be presenting this work at WWW06 in Edinburgh next month. If you’re going to be there contact me.

07:41 PM | Comments (1) | Recommend This | Print This

April 06, 2006

AJAX Color Tool

Here’s a nifty little AJAXy color tool demonstration. Once you pull out the tool, drag colors from the bottom of the box to the black boxes on the right hand side of the Web page to see the effect of that color on the layout.

09:10 AM | Recommend This | Print This

March 16, 2006

Bret Dixon on SOA

in his keynote presentaiton, Bret Dixon of BEA made an interesting comparison. One viewpoint is that of the single technology stack that has these characteristics:

• invest to reach homogeneity
• get everything you need from one vendor
• replace what you have
• periodic releases will give you enhancements

The other view point is a single service nertwork that has these characteristics:

• heterogenous products make up a network
• commitment to open standards
• uses different products to get needed functionality
• incremental increase in capacity and functionality

SOA means that the software the links applications become more important and are among the most improtant strategic decisions that a CIO makes.

SOA Initiation Patterns (click to enlarge)

How do you role SOA out in your organization. Bret gives four patterns in the form of a 2x2 matrix that plots SOA complexity vs. Business sponsorship.

When sponsoship is low and the appetite for complexity is low, you have process projects that are characterized by having no CIO driven action plan. Starting points: identify a service with an opportunity for reuse. Design it, build it, and prove it out. This might be a skunkworks project.

When the CIO is involved, you can have more complex projects. Bret calls these IT-led projects. These are focused on infrastrucuture-based services. Start by creating an enterprise reference architecture and roll it out using in a multi-period roadmap. This requires that you establish an enterprise architecture group.

Bret Dixon of BEA Speaks of SOA Executive Forum (click to enlarge)

High business sponsorship and low complexity results in business-led projects. In these cases, the IT team doesn’t typically have the confidence of the business and the budget is limited. Often the CIO and team enthused about SOA. Start by finding a key business project. Identify a project with SOA needs. Architect it in a SOA manner by specifying services and demonstrate SOA capabilities.

With good business sponsorship and complex environmets, you end up with mega projects that results sweeping business change with significant IT impact. This doesn’t happen very often and requires big budgets.

Governance and organization lessons

1. Don’t make the answer more difficult than it has to be.
2. Don’t engage in drastic reorganization, but put pressure in place to encourage alignment of business, development, and operations.
3. The CIO has to be a leader.
4. Align around specific objectives: speed, reuse, agility, etc.

The conclusion: get started! Know your entry point. Plan and manage holistically (multiple dimensiont and periods).

11:13 AM | Recommend This | Print This

Jeff Gleason on Achieving Reusability with SOA

I’m at InfoWorld’s SOA Executive Forum this morning in San Francisco. I’ll be conducting a panel on SOA governance later this afternoon. There’s a sellout crowd. InfoWorld really knows how to put these things together. I also know from working with Eric Knorr, Steve Fox, and other editors at InfoWorld that they try really hard to make sense of this, create good ways to explain it, and develop sound advice.

The opening keynote is by Jeff Gleason, Director IT Strategies, Transamerica Life Insurance Company. He’s speaking, from experience, on achieving reusability using SOA. Transamerica provides life insurance, pensions, and related investment products with the typical product offerings you’d expect. The complex piece, the part that drives SOA is the distribution network of independent agents, broker-dealers, banks, and other financial institutions

Jeff Gleason of Transamerica speaks at SOA Executive Forum (click to enlarge)

The product Transamerica offers is not, of itself, a sustainable competitive advantage because competitors can copy products in a short time. Giving customers and distribution partners good service is the competitive advantage. In addition, the legislative and regulatory burden is heavy and there is considerable economic pressure (low interest rates, consumer confidence, competition, etc.)

The technical challenges include legacy mainframe systems running COBOL apps on VSAM, lots of complex, P2P integrations, redundant tools, and limited documentations and metadata. All this has created a brittle complex architecture that has created rather then being planned.

The environmental challenge includes a project-based culture, architecture, process, and tools. Last year there were 800 projects that resulted in something entering production. Jeff explains what he means by “project based architectures” as an architecture that has been built up over time where each project does what works best for that project. The result is an architecture that doesn’t support change even though IT is the key vehicle that business executives use to support change.

In 2003 Transamerica started a project to define a strategic architecture. The strategic architecture has an integration focus for both applications and data. The architecture uses business services for functional encapsulation, BPM for process orchestration, BAM for process visibility, and a portal for user interface integration. The methodology is SOA.

Jeff shows an as-built diagram of their high-level integration diagram as it existed early in this process. The policy administration system is the core piece. The diagram looks like a plate of spaghetti. Splitting this diagram up shows lots of redundant functionality. The future-state diagram shows three layers: data, elemental business services, and composite apps. The data layer is not just a database, but includes infrastructure pieces like CRM, accounting, etc.

The first project enabled policy valuations. This was a batch-oriented process with multiple applications and data stores. There was significant ROI and great opportunities for re-use because this process gathers data that’s core to the business. Business partners require valuation data (via SLA) in a timely manner, but as the number of policies grows, the ability to calculate the value goes down.

There were three key lessons learned:

• Re-use doesn’t happen in a vacuum. You need steward to implement and guide the process.
• You need tools to understand what you have and what you need.
• Process can be used to level the skill sets needed.

Two perspectives on reusability. What exists and how can it be reused (legacy apps, data stores, etc.) Whoops, missed the second.

The stewards for reusability are the architecture team. They look for patterns and standards and provide architecture level consulting and governance. There are business patterns, applications patterns, and product and technology mappings. An Integration COE shows how to implement the patterns and standards picked by the architecture team and provides implementation level consulting and governance.

Tools for reusability let you see what you have and model what you want. For example, they’ve created an business event viewer and records information about business events and can be browse or search these records. A second tool (built on Rationale’s Requisite Pro tool) tracks business event tractability. This shows events, actors, and the object of the event.

A business architecture map shows how business event, functions, services, transactions, and data stores are related. This related the business architecture to the technical architecture. The map and other tools show where reuse is possible because redundant functionality can be seen.

The are four important parts of their process for reusability.

1. New roles of technical and business architects have been created. They identify business and technical opportunities fore reuse, integration, and consolidations. They’re also responsible for requirements management.
2. Minimize Risk by identifying risks, developing prototypes, and using iterative development.
3. Ensure Quality with quality gates and iterative development.
4. Be seamless by tracking changes through requirements, designs, technical artifacts, test cases, and test scripts.

This process has had a real impact on design yielding configurable and dynamic services. For example, in creating a new design for agent validation services, Transamerica found components that have since been reused in three other systems.

SOA is not about technology like UDDI, WSDL, and SOAP and more about the organization that uses those things. Jeff didn’t use the word specifically, but what he’s really saying is that reusability requires good goverance and enterprise architecture.

10:31 AM | Recommend This | Print This

March 08, 2006

Alex Russell on Comet: Beyond AJAX (ETech 2006)

Alex Russell, who works at JotSpot and did the DOJO Toolkit for JavaScript is talking about Comet and low latency data to and from browsers (slides). The subtitle is “after AJAX.” The goal is responsiveness. AJAX gives you half the answer. AJAX is about me. Social applications are driven by others—the multiuser web. How do we send the datagrams that users make to each other.

To any one user, the server represents the other users. Because the Web is a multiuser experience, single interaction updates aren’t enough. Users in the same “space” need live updates of their own changes and the changes others make. Updates to content affect available actions. Stake context may mean the wrong decision.

If the Web is a conversation, then stale context kills. When you create a page, or tag a picture, or something else, you’re chaining context. Conversation mediums are defined by latency, interrupt, and bandwidth. He gives some examples (in order of latency): snail-mail, email, IRC, SMS, IM, phone, and finally face-to-face.

Polite users use high-interruption mediums as infrequently as possible. Traditional wikis are fraught with usability issues.

Wikis are conversation enablers that are traditionally medium-to-high latency and not well suited to high volume changes. There are locking issues. AJAX allows more context to go stale. What is changing on the wiki as I edit? Who wants to break my lock? Have attachments been added? Is the text of the page itself changing?

Conversations are ordered events. Granular interfaces require granular events. Granular conversations are more immediate (IM vs. email). Social applications are even busses. Social web apps just batch changes today. The are no effective was to “subscribe” to server events today. To fix the context, we need to syndicate the events.

Event broadcast requires synchronization. Comet is a technique for pushing data from the server. New term, but old tech. This is enabled by long-lived HTTP connections instead of polling. There are similarities to AJAX: no new plugins, plain-old HTTP, asynchronous, broad browser support.

Here are some examples of systems that use Comet: GMail, GTalk, JotLive, Renkoo, Meebo, cgi.irc, KnowNow, and others. Note that Comet isn’t a framework or toolset, its a concept like AJAX. Alex is coining the term Comet so that it has a name.

How is Comet different from AJAX? In an AJAX application, the client drives the interaction. The problem is that context and manipulated content go stale at different times.

Comet application fight lag by avoiding HTTP and TCP/IP set-up and tear-down and a single connection is re-used. But the big kicker for AJAX is polling latency which Comet avoids. The big takeaway: transfer only the necessary data, exactly when it’s most relevant.

There are two implementation techniques: Long-polling where you reconnect after every datagram. This is simple to implement with XmlHTTPRequests. Another method is to use multi-part XmlHTTPRequests. This works differently on IE and Firefox and doesn’t work on Safari. No known system does this portably today.

Another technique can use what Alex calls a forever-frame. A forever-frame is an iframe or browser frame that receives script blocks and uses progressive rendering. This is highly portable and allows connections to subdomains. The connection only closes when there’s an error of the connection recycles.

Most commodity Web servers won’t cut it today. This is why the alternate subdomain idiom is important. You can run the main app off the primary Web servers and then do the continuous updates to a special server. The problem is that each connection takes a process or thread and there might be thousands of them. Comet can reduce load but not on your current Web infrastructure. Polling is a latency trade-off. Comet is an architectural complexity trade-off.

WE need better event based tools. Servers don’t know about events as such. OS’s have edge-triggered event IO mechanism (epoll on Linux and kqueue on FreeBSD). At the network level, we need application environments. Perl’s PEO Python’s Twisted, Java’s Jetty and event_mpm from Apache (in 2.2). The good news is that the OS’s can handle it.

The news on the client isn’t so good. Clients can’t make more than two HTTP connections to any box/subdomain (per spec). Firefox may not adhere to this limit. IE is draconian. The JavaScript code needs to know about this and deal with it—right down to peering with other browser instances and managing connections

There are some workarounds: multiplex events for multiple components over the same connections. We need message oriented middleware for the client. You can also use DNS hackery with wildcard DNS to increase the available subdomains.

Is Comet good for users? If users are all trying to do the same things at the same place to some piece of data, then you need it. Can presence data improve the conversation. If the data can go stale and no one notices, then you don’t need it.

Some early lessons: work with interaction designers. Learn from desktop apps—they have the same design problems. be consistent. Let users know why the data is changing and who changed it. Communicate connection failures clearly. Push data updates, not functionality changes.

Update: Randy Gordon pointed me to this work on an architecture called SEDA which stands for “staged event-driven architecture.” i haven’t read through it yet to get a handle on it, but I didn’t want to lose it—attaching it here may be useful to you and will definitely be useful to me.

04:14 PM | Comments (1) | Recommend This | Print This

Mary Hodder on iTags (ETech 2006)

Mary Hodder is talking about itags. An itag is a tag + author identity + CC license + media object. Media objects can be text, photo, video, or audio. Trusing tags means trusting the maker of the tag. By uniquely identityfy the object, the tag, the author, and the licensing; the itag can live anywhere.

The goal of all this is to put tags and objects together so that they can be included in places like feeds. “I-tagging would remove the requirement for a tag to be coupled with the originating URL (blog post URL) because identity would be inside it.”

The assumption of rel-tag is that the tag is the object. The assumption of itag is that the tag is the subject and the class attribute is the object. Still because backwards compatibility is important, itags use the same syntax as rel=tags, and just adds a class attribute. The class attribute is a URL. There are other variants for licensing itags.

One thought I have in looking at this is that the licensing style of markup would be an effective way of adding identity rights to marked up identity data.

As a meta comment on the presentation, Mary used NovaMind to gather the relvant issues surrounding here central premise and then presented by following the branches. I found it to be effective, but the fonts could have been bigger. I had trouble reading it in the second row. I pity the people in the back.

03:32 PM | Comments (2) | Recommend This | Print This

Brian Dear on Eventful and EVDB (ETech 2006)

Brian Dear from EVDB and Eventful is speaking on calendar as platform. His talk is title “When Do We Get the Events We Want?” He gives a quick overview of the company. EVDB stands for the Events and Venues Database. The goal is to maximize event discovery. The Web has done a pretty bad job of getting people to the events they’re interested in. Making data for events open and portable is important, so is having the right tools to manage that data.

The company has a platform called EVDB and a portal called Eventful. Anyone can use EVDB. The portal has three dimension. First, known events and the various capabilities like search, groups, submission, tags, feeds, etc. that go along with that. The primary goal is attention for the event.

The second dimension is expected events. These events don’t exist yet, but they’re expected to happen in the future. The primary tools here are prospective search and notifications. An example: notify me if Tim O’Reilly is ever speaking within 100 miles of my zip code.

The third dimension is about dream events. These are events that you wish would happen. The primary tools provide a way of aggregating demand. This isn’t just a wishlist. The goal isn’t to sell the demand data to labels or promoters. This is about fans and performers. Unconferences are an example of this in the tech world. This is basically a marketplace for experiences.

Brian shows off the tools for creating demand. This feature just launched today. The tools are pretty cool. Good creation tools, ways to create blog stickers, and a dashboard for following what’s happening. Demanding something doesn’t mean you’ll get it, but this feature at least let’s you try.

11:14 AM | Comments (1) | Recommend This | Print This

March 07, 2006

Microformats (ETech 2006)

Tantek Celik or Technorati and crew are doing a microformats talk. He says that microformats are more than just good class names. There are principles that keep things “micro,” process that emphasized getting real, and community that minimizes duplicates.

Here’s the process:

1. Pick a specific, simple problem and define it
2. Research and document current web publishing behavior
3. document existing formats in the problem area
4. brainstorm with implied schema and reuse names
5. iterate within the community

Rohit Khare takes the mic to talk about work he’s doing on microsearch for microformats. One is called miffy. I didn’t get the name of the other project. miffy pops up a window that shows microformats on a page. You can send data you find to a index that provides streaming, pubsub-like capture of the stream for display, searching, etc.

Mark Pilgrim takes the stage to talk about magicwand, a GreaseMonkey script that understands microformats. Magicwand searches on pages for microformats (and other things) and gives you a command line for finding them.

Yoz Grahame of Ning shows how microformats are built into Ning. Ning is a social software framework, so there’s lots of room to use hCalendar, hCard, and other microformats.

07:06 PM | Comments (1) | Recommend This | Print This

Derek Powazek on Community

Derek Powazek is talking about new communities on the Web. He says that the Web is less about companies createing “company” towns and more about people creating their own spaces. He uses the Technorati Top 100 bloggers as examples of people who have enormous reach and create their own community.

Company town are communities, but they’re extrememly authoritative. If you step out of line, you can find yourself out of the community. When you create your own community, that’s no longer true.

Derek mentions MeasureMap as an example of a site that helps manage community—showing visitors and posts. I’ve wanted to see connections between posts I make and the traffic then generate. Maybe this tool will do that?

ORBlogs is an example of community creation. It’s an aggregator of blogs in Oregon. Similar to what we’re doing with the “other voices” section on the home page of UtahPolitics.org.

There are pros and cons to self-ownership of community.

On the pro side: self-ownership means no one can turn you off, it’s more human in scale, there are fewer bozos, and no one graffitis their own house.

On the con side: no one’s in chrage, there are no moderators, it’s harder to converge and the tools are still difficult.

Living in a company town is like living in your parent’s house. There’s some comfort in having someone else in charge, but you have less freedom. Eventually we move out because the freedom is more important than the convenience.

Here are examples of modern company towns that play nice in a networked world:

• Flickr: open APIs, RSS, tags, blog this photo
• YouTube: Blog this video, contribution culture
• MySpace, Friendster, etc. public/private to some degree
• TypePad: Decentralized, but still SPOF (single point of failure)
• Last.fm: Connected to apps

Some advice: Treat your community well because they’ll leave if you don’t. On the other hand, they may leave anyway just because they want more freedom. You can’t create community in the Web of today. Go to the communities that form. He gives an example: he and his wife created a magazine called JPG. Rather than creating their own online community, they created a group at Flickr. Now they have over 10,000 members in their group and are one of the top ten groups at Flickr.

05:24 PM | Comments (1) | Recommend This | Print This

Cory Ondrejka on Web 3.0

Cory Ondrejka from Second Life is speaking about what he things is one of the most interesting aspects of Second Life: the departure from the usual pain vs. participation graph. Even though making things in Second Life isn’t easy, there’s an unusually high participation rate. People who use spaces like Second Life tend to look at them as real space. These are garnering a lot of the attention that people spend.

The economic scale of Second Life is impressive: over the last 30 days, 240,000 distinct items were bought an sold. The conventional wisdom is that user created content wouldn’t be high quality, but that’s not the case.

Cory talks about users protesting taxes by lighting stuff they’d made on fire. That obviously affected user acquisition.

Second life has 90,000 hours of usage per day. If you do the back of the envelop calculation to figure the cost of developing all the things people in the space make, it’s about $400 million/year.

UC Davis created a virtual hallucination simulator so Second Life residents could see what it’s like to be schizophrenic.

Second Life demographic data shows it’s gender balanced and older than people who play games. There are hundreds of classes on Second Life about how to use Second Life. Amateur to amateur teaching happens all the time. There’s great opportunity to apprentice and learn from experts.

12:38 PM | Recommend This | Print This

Bruce Sterling on the Internet of Things (ETech 2006)

The evening keynote (last night) was by Bruce Sterling on the Internet of Things. This was one of those talks that is impossible to blog. Even a word-for-word transcript wouldn’t do it justice because Bruce’s delivery is as much a part of the content as what he says. I’m sure it will be on IT Conversations soon and I encourage you to listen to it there.

Bruce’s message was about language and the power of naming. He said, that when it comes to remote technology, you don’t want to freeze your language too early. It limits the ability of people to find the intrinsic value. Artificial intelligence is an example. Computers are not intelligence. They boxes of circuitry. They just sit there “ordinating” as the French say.

Bruce gave a great example about whether you’d want to have Google or Alan Turing in a Box (a reference to the famous Turing test). It brings into stark contrast the difference between AI and what we’ve built without AI. He makes the claim that a tech world that talked about computers as ordinators or sorters or card shufflers probably would have invented Google in the 1980’s. The new stuff, people interacting with technology, is what’s important. On demand social application are unimagined by Computer Science.

The idea behind the Internet of Things is laid out in Bruce’s book Shaping Things. He envisions the Internet of Things doing its work in six interesting ways:

1. interactive chips
2. local and precise geolocative systems that sort out where you and things are
3. powerful search engines
4. sustainability through auto recycling
5. 3D virtual models of physical objects
6. rapid prototyping of object

Bruce calls these Internet things “spimes” because they’re tractable in space and time. Manufactured objects that are material instantiations of an immaterial system. They are virtual object first and actual object second. The primary advantage is that you no longer inventory your possessions inside your own head. That work is done far below your notice by a host of machines. You just ask where things are and where you bought them and what you paid, and so on. You no longer wonder where your shoes are, you just google them.

Why create a new word? Because it creates a cloud of associated commentary and data online. This is an example of what Tara McPherson calls a theory object. Theory objects accrete attention and generate trackable trails of attention. Any real theory object has trackbacks and pictures and a FAQ and so on.

Bruce isn’t talking about some smart object with a processor inside, he’s talking about everyday objects that have unique digital identity. When they work well, new words like spime are like good brooms that get rid of old words. This is different than hype. Hype is a system call on your attention. Hype is aimed at your wallet.

Bruce continues with a riff about hype in technology and politics. In technology, the opposite of hype isn’t the truth (like it is in politics), it’s argo—technojargon. Techjargon is a superspecialized geek cult language. It’s deliberately hermetic. But, a small clique doesn’t have enough people to successfully name things. It takes a whole lot of people to manage a popular language.

Bruce doesn’t think that ubiquitous computation will be either ubiquitous or computation. It will be patchy and limited like cell phones. It’s not a smooth supported product. As we move in that direction, you don’t want to avoid the contentions of the literary struggles. The words are signifiers of the places where things aren’t yet hammered out.

Let’s take “Web 2.0” He quote’s Tim’s definition. Bruce says that this definition is not a clean, sanitary things, rather it’s about people Tim thinks are important and the causes and values they hold as a class. He then quotes Alan Liu on the idea of Web 2.0 who is highly “skeptical.” There’s too much of the “high priesthood” of administrators who work behind the scenes to make it work.

Bruce goes on about this because it matters. Naming can make completely new concepts and make them everyday. That’s the goal.

The presentation was very entertaining (which is saying something given that it was starting at 9pm). Of course, with Bruce Sterling, you’d expect nothing less. Like I said earlier, you’re going to have to listen to it to get the fine nuance. I’ve ordered a copy of his book because I’m interested in the identity aspects of what he calls the Internet of Things.

10:31 AM | Comments (1) | Recommend This | Print This

March 06, 2006

Ray Ozzie's Clipboard for the Web (ETech 2006)

Ray Ozzie is the first keynote of the first day. He’s talking about building composite applications (what he’s calling mashups) on the Web.

The real power is bringing composite apps to the user level. A reference to shell commands and pipes in UNIX bring a good image to mind for anyone who’s done that. GUIs bring big apps that user weave together using the clipboard to accomplish work.

The Web has a lot of standalone apps. Where is the clipboard for the Web?

Ray launches into a demo of “live clipboard.” This simulates a button control inside the browser that cuts and pastes a structured data item (snippet of XML, microformats, etc.) Point of interest: he’s doing the demo in Firefox.

When something is cut, it’s put into the clipboard as an XML structured piece of data. He shows a demo of cutting an event from Eventful and posting it on the Windows Live Calendar. The same paste works in Outlook as well because of a system tray program that watches the clipboard and makes sure the right things happen by reformatting data in the clipboard on the fly as needed. He shows another demo of pasting addresses from an address book onto a Web form.

This is a nice way of adding functionality in a way that users already understand. So far all the demos have been about bridging data between applications. What about feeds?

Three kinds of aggregators, standalone, online, and the browser. We’re all disappointed that the RSS technology is a leading edge kind of thing restricted to technologists. Ray thinks there will continue to be a demand for aggregators outside the browser.

This creates a mess since there’s no standard for adding feeds to aggregators. With the clipboard functionality, you can simply cut and paste the feed and the clipboard will reformat the data as necessary.

You can cut and paste, but that’s static. Ray shows another icon that links one spot on a Web site to a tiny subscription to data on another. So, you can link two Web sites so that changes on one show up on the other. He demos this by linking his current location in his FaceBook profile to his current location as given on his blog. Going further, he pastes subscriptions to his friends locations onto the Windows Live map.

The bottom line: there is power in simplicity. The Web is a collection of really useful hacks. If we, as a community, decide to extend the power of the clipboard to the Web, then we can change how people work. Microsoft can put it on it’s Web site, but we need everyone to help. Instructions will be on Ray’s blog.

10:34 PM | Recommend This | Print This

March 03, 2006

SOA Governance Panel

I’ll be moderating a panel on SOA governance at InfoWorld’s SOA Executive Forum March 16 in San Francisco. This will be a follow-on to the feature I did on SOA governance that ran in January. The panelists will be:

• Todd Biske of AG Edwards. Todd blogs actively about SOA. He had a recent piece about governance with an analogy to voting that I enjoyed.
• Ed Vazquez of Sprint-Nextel. Ed’s the Group Manager of the Web Service Integrations & SOA.
• David Harrington of MedicAlert® Foundation. David’s the CTO at MedicAlert.
• Mystery Panelist. We’re still waiting for confirmation on this guest. Trust me…whoever it is will be good.

As I started putting this panel together, I wanted to get people who were using SOA and had run up against governance problems. It’s easy to get vendors to come and talk and they do a good job, but the stories are second hand. I think the discussion on this panel will be real, hands-on experiences. At least, I hoping…

The panel will be run with a strict moratorium on PowerPoint slides. I’ll spend 3-5 minutes introducing the subject, give each panelist 2-3 minutes to introduce themselves, and then we’ll launch into questions. I’ll have some prepared and also take audience questions. Here are some of the questions I’ve been thinking about asking:

• Why is governance important?
• How does your company govern SOA?
• What big mistake did you make early on that convinced you that you needed to govern your SOA efforts?
• What role do policies play in governing SOA? What policies do you have?
• How do you distinguish between design-time, deploy-time, and run-time policies? Do you treat them differently in the governance process?
• Do you have a center of excellence (COE)? What role does it play? How does it work?
• How are governance and architecture related?
• Have you encountered resistance to SOA governance in your organization? How do you overcome it?
• How do you enforce policies? Who enforces policy?
• What process do you use for feeding back information from enforcement and taking corrective action?
• Is any of your policy enforcement automated (WS-I checks for example)? How do you do it?
• What role do registries play in your governance efforts?
• What role do Web services management systems play in your governance efforts?
• Do you use SLAs or other contract devices between providers and consumers? How are they managed?

If you’ve got other questions about SOA governance that you think ought to be addressed, please leave a comment.

03:15 PM | Comments (2) | Recommend This | Print This

February 13, 2006

SOA in the Public Sector

I’m quoted in an article in Public CIO magazine. I was interviewed for this story on the use of SOA and Web services in the government so long ago, I can hardly remember it. The article, especially the last line, makes me look less enthusiastic about SOA in the public sector than I am. I think public sector CIOs have a great opportunity to use the governance powers that they already have, in connection with relatively modest expenditures on infrastructure to build real connectivity between departmental silos.

10:05 AM | Recommend This | Print This

February 06, 2006

SaaS Lessons Learned

I’m at the Enterprise Software Summit in Sundance this afternoon (I’m speaking tomorrow). Greg Gianforte, from Right Now, is speaking about things they’ve learned about supporting software as a service (SaaS).

1. Deployment choice - on premise and hosted. Large enterprises, particularly financial and government, need an on premise solution. You need a software architecture that supports both. Installations often go to a hosted solution, hosted solutions rarely move to on premise installations. Software has to be architected from the start with multi-tenancy in mind.
2. “On demand” does not equal “pay as you go” Separate the way to pay from the type of installation. Options include term paid monthly, term paid net 30, and perpetual license plus maintenance.
3. Upgrade choice - Forced upgrades don’t work—give customers the choice of when to upgrade. You can’t update people’s work environment without upsetting their work. They need to be trained and customers need to be in charge of when that happens. Multi-tenancy must support multi-version as well. You have to automate the upgrade process. Allow users to create a sandbox with their site in the new version and play with it.
4. Customers want integration choice. The SaaS must integrate seamlessly with the company’s existing infrastructure. For example, how doe it integrate with existing warranty, credit card processing, and order fulfillment systems? Web services remove location constraints and abstracts data.

It all comes down to customer choice. The only way to do this and not bankrupt yourself is to architect for it.

04:07 PM | Comments (2) | Recommend This | Print This

February 02, 2006

Ben Galbraith: Ajaxian

Ben Galbraith is an Ajaxian. I met Ben when he was president of the Utah Java user’s Group. Ben’s also the author, along with Justin Gehtland and Dion Almaer, of Pragmatic Ajax : A Web 2.0 Primer. I’ve always been impressed with Ben’s talks and writing, so I’m anxious to pick up a copy and see what he has to say.

10:03 AM | Recommend This | Print This

January 24, 2006

Synapse Milestone 1

The Apache Synapse project released Milestone 1 yesterday. From the homepage: “Synapse is a mediation framework for Web Services. Synapse allows messages flowing through, into, or out of an organization to be mediated.” Milestone 1 supports:

• Simple mediation based on regex and xpath rules
• Onbound routing of messages
• Deploy simple Java mediators to perform logging, routing, message transform etc
• XSLT transformation of messages
• HTTP Proxy support
• Stages and in/out handling of messages

There are a number of SOA intermediary vendors, like Infravio supporting Synapse in the hope that it will spawn a standard, open source reference architecture for Web Services control points. Everyone wants to be in the run-time management business without having to manage all the connectors, gateways, and proxies that get managed.

I haven’t played with Synapse yet, but it might be a fun thing to throw into my class next fall. I’ve been thinking of cutting out J2EE and just concentrating on Web Services. That would leave time for students to get their hands dirty with intermediaries, orchestration, and some other more advanced SOA artifacts.

06:55 AM | Comments (2) | Recommend This | Print This