Brandon Werner

If you don’t read Susan Cramm’s articles at HBR, you should. It has great stuff that deals with the intersection of technology and business in brutally honest fashion. Cramm has been both a CIO and CFO, so she’s seen it from both sides and gives a honest and direct point of view from the business space. This particular podcast from the Harvard Business Review talks about these frustrations in general terms. We should figure out how perhaps our behavior and processes can lead to this frustration (I can think of a few)

http://discussionleader.hbsp.com/cramm/2008/06/8-things-we-hate-about-it.html

Overview:

1. IT Limits Managers’ Authority You bring in 10% of the company’s revenue but can’t authorize a $100,000 project if it requires IT. Furthermore, IT’s bureaucratic governance process rivals the tax code in complexity and inhibits rather than promotes innovation.
2. They’re Missing Adult Supervision The CIO is impressive, but totally unavailable. So the next best option is your IT “relationship manager" who’s a few clicks down the evolutionary scale and doesn’t have the breadth of expertise to truly act as a trusted IT advisor to senior business executives.
3. They’re Financial Extortionists When was the last time there wasn’t some emergency in IT (e.g. Y2K, SOX, HIPAA) that requires a zillion dollars? Compound this with the lack of visibility into how IT spends non-project dollars and it makes you want to become a technology vendor to cash in on the booty.
4. Their Projects Never End In-process projects are always 90% done. "Completed" projects don’t have agreed to functionality, and the team that promises to deliver missing functionality in future phases are always mysteriously missing-in-action.
5. The Help Desk is Helpless When glitches emerge, you are become a technology pauper, going door-to-door begging for help while functional specialists defend the reliability of their piece of the byzantine infrastructure.
6. They Let Outsourcers Run Amok You know that outsourcing wasn’t really IT’s idea, but you blame them when you’re trying to communicate with external “service” providers that lack even a basic understanding of your business. It’s like trying to teach calculus to a 4 year old.
7. IT is Stocked with Out-of-Date Geeks It’s not good when you learn about social networking from your 12-year old at home while IT is still trying to cope with email. Then, when you try to brainstorm with IT about how to apply new technology, you get paternalistic responses akin to the look that parents give their children when they play dress up.
8. IT Never Has Good News No matter how much you spend and how hard you work, you never have anything to celebrate and little to look forward to as the promise of technology seems perpetually beyond your reach.

What do you think of this list? Is it out of line or hit uncomfortably close to home?

This is a presentation I created to describe how SDOs can be used in the Insurance enterprise space to provide sanity in the large and diverse messages. These are increasingly being passed around as Business Objects in a Domain architecture as companies move their old object patterns to a service based approach (I refer to it as servitized business objects).

If you are looking for my particular experience on how SDOs and the IBM EMF framework that contains them works against the large ACORD schema, you can find my critique of Websphere Process Server and ACORD here and the SDO design pattern plugin I wrote for Rational Software Architect here.

You can download the slideshow here.

I seem to be visiting a lot of my prior entries from 2005, but a while back I wrote about an experience I had meeting an old IBM programmer at the local Catholic store. She was female, which seemed like a trail-blazing thing to have been working in the heavily male dominated technology industry in the 1950s. Her story, and her eagerness to share with me, led me to write my experiences with gurus in my life, entitled In The Presence of A Guru (On Catholicism, VAX/VMS and Geek Culture). I still feel profoundly stupid for not having spent more time with her, as it was obvious she wanted to share her story. I will regret it for the rest of my life, not just because of what the exchange could have done for my understanding, but more refusing my obligation, the obligation we all have, to listen to and carry on the mythology and history of our elders. I am afraid that mythology may be vanishing, and none of us are listening.

I thought about this again when I stumbled upon a new blog from Dan Weinred as linked from Lemonodor. His career in Computer Science and his contributions certainly qualifies him as a Guru.

His essays so far are a treasure trove of information and computer science archeology. One of my favorites is called The Technology and Business of ObjectStore, where he recounts taking his ObjectStore technology to Microsoft and Bill Gates as well as Steve Jobs. The reaction of both icons demonstrates humorously their approach even now:

When the new Windows technology (which was OS/2 at the time; IBM and Microsoft were still working together on it) came out, it was crucial for us that it be able to support memory mapping. Dave Stryker and Tom Atwood, flew out to meet with Bill Gates in September of 1989. Dave Stryker recalls: “We originally had a 45-minute appointment, but Gates extended the meeting to a couple of hours, and called in Dave Cutler [the architect of OS/2]. At Tom’s urging, we told Gates and Cutler everything they wanted to know about ObjectStore. Gates was complimentary of the Object Design approach, but said, in a nice enough way, that if the Microsoft Empire ever needed such a thing, they would build it themselves. Still, Gates told Cutler to make sure that the OS/2 equivalent to mmap was powerful enough to run ObjectStore, and there were some changes made to make it so.” Later, this OS/2 technology turned into Windows NT. Dave Moon adds that it turned to have a bug: it doesn’t free up disk space when it ought to. For some reason Microsoft hasn’t fixed this, even after many years. We found a way around it.)

Speaking of industry luminaries, we also met with Steve Jobs when he was at NeXT, and Jobs made a big announcement praising our technology, which resulted in a nice press release. There was some discussion that NeXT might buy Object Design, but that never went anywhere.

This type of history is fascinating and important. There have been efforts to capture this knowledge, such as Fokelore.org and ACM’s excellent ACM History Committee trying to archive CS knowledge, but their efforts so far is approaching it the wrong way. It’s getting the stories, while these people are still alive and can tell them, that is important. Much of it will not be academic or well checked, but that is missing the point. It’s the mythology as well as the history of these pioneers in the 1930s - 1970s that we should be after. We’ve already lost Jeff Raskin, Adam Osborne and others.

If we do not do this, their legacy and our history as a profession, one that has changed the world as much as any other in human history, will be lost forever.

Way back in 2005 I wrote at length about the danger we all face putting data online. Back then, I was running The Planning Studio Inc., and we had experienced a lot of expansion and were outgrowing Salesforce.com as a Sales/Contact manager. When we became aware that extracting not just our data but also the relationships between those data was impossible, I wrote a word of warning to the blogosphere about data. I would have assumed three years later there would have been a common and demanded way to export your data. Sadly, that is not the case. Scoble became a victim of this with Facebook, and what shocked him was what occurred to me back in 2005: In Web 2.0, you don’t own your data.

It’s Not Just About Your Data, It’s About The Relationships Between Them

Although a few bring up the fact there are some ways to export your data from these various services, that missed the point badly. What Scoble and the rest lost, although they may not have been able to articulate it, was the work they put in to their data. When we import our data in to a social network application, we don’t expect to leave it in a static state. We usually import our address book and calendar, among other things, so that we can then begin creating relationships and making our data more valuable.

Think of the tagging feature in Flickr and Facebook. How often have you sat and painstakingly tagged your friends or photos for maximum social use? You may have even organized your photos in to sets that would be more viewable and easy managed, spending hours uploading and tagging. What about the APIs that allow you to visualize, browse and draw conclusions from this metadata that exists from these relationships you’ve made? You may have seen relationships you had never expected. By using social applications on the web, you have changed and made your data more useful, as simply as if you imported a CSV file in to Excel and made graphs of that data.

Does that mean that Microsoft can claim that data and the charts you’ve generated are their property? Can they take those graphs and spreadsheets away at a whim?

The same problem applies to Google and Yahoo!, among others. While many wonder if these Web 2.0 application providers are looking at our confidential data, the real worry is if they decide you can’t anymore. Although Google says publicly they have no process to look at our data we store on their servers, they most certainly have a process to remove you from it if you violate their Terms of Service, something that is at best arbitrary and a process in which you have no legal right to appeal.

The Worse Part Is, Your Hard Work Benefits The Social Network Too

The most insulting part of Facebook and others wielding that sort of power over our meta-data is that it’s through our hardwork their service is useful. Although you could call our work managing and forming relationships between our data a non-zero sum game as we also reap the benefits of the connections, our hard work makes their social websites a better and more fun place to be. If no one took the time to tag their friends in their photos, or enter tags on blog postings and pictures how interesting would these places be? It seems to me that claiming complete control over that data is a slap in the face no user of social networks should tolerate. The same holds true for other Web 2.0 apps that manage our data, including Google and Yahoo!. Deli.cio.us would Just Another Bookmark site if it wasn’t for the hard work it’s users put in to tagging and managing their bookmark data.

Although social networks can be considered non zero-sum, other Web 2.0 companies are decidedly zero-sum; we do all the work. Although there is no social component to these services, it is usually this data and the relationships between them that are more important. Many small businesses use Salesforce.com and have their business contacts linked to companies they bill for services which are in turn linked to billing and payment systems. If they don’t pay their bills for a month, or worse if they wanted to take their business elsewhere, that painstaking work linking these data pieces together, notes and all, would be lost. The same is true with financial analysis of your bank account on Mint or Notebooks on Google.

How To Fix It

Being in software architecture for large enterprise systems, the solution to this seems simple and easy. We need a way to export this data in XML or some other format that, even if it doesn’t contain the content itself (pictures and files would not be practical) the relationships between this data could be exported. It need not be wrapped up in some long drawn-out collaborate standards body in which Flickr, Facebook, Salesforce.com, MySpace and IBM (they join every standards body) would sit down and spend five years coming out with a standard.

My proposal? Facebook just does it.

In the Web 2.0 world, the prime mover is usually the standard maker for the rest of the industry. When Facebook provides it’s users with some export tool, no matter how complicated or mangled the XML would turn out to be, immediately developers would come up with tools to parse and import this data in to other applications and systems. Some would even take this data and provide analytics across various networks, something that other websites are attempting to do but at a substantial risk to your privacy as you must provide them with your login credentials to every site you belong to. Facebook may be bearable to give your login information to, but your Amazon.com profile with your One-Click Buy enabled is quite a different matter.

Other Web 2.0 environments, either through customer demand or marketing reasons, would be quick to follow. Soon, some standard schema would emerge that would be predicable or at least validated online by the services themselves. XML transformation is standard fare in the enterprise world, and there are many C# and Java developers who know how to transform some XML to another XML standard with their eyes closed. It could open up more avenues for migration and populating social networks, as well as doing personal and business analysis of your data.

Whatever the format, as long as the data inside the file is described and well formed (what XML was designed to do, describe the data it contains so any software can make sense of it) we should be able to make quick work of migrating that data to other services or applications.

Why It’s Important

Although we often don’t see it, Scoble, you and I are still “in the bubble” when it comes to technology and social media trends. We often think that because something is important or obvious to us, the rest of the world should be up in arms about it as well, when in reality they are just sitting in the living room watching TV. There are many users of Salesforce.com, Facebook and Google Notebooks that don’t think about this problem, or worse assume that there would have to be a way because it’s just logical there would be. Why would they take your friends and your photos away without giving you any recourse? Why wouldn’t you be able to export your entire client list and company list and maintain those relationships? Even just drag them in to Quickbooks Professional Edition? Wouldn’t there be some law making sure they can do that?

The answer is no. Hopefully, those who have larger voices than I did in 2005 will take this issue to a more public sphere. The danger is that this problem fades back in to the blogosphere, where Scoble gets his traffic and his hits and moves on. I don’t want to write this article again in another three years.

We should do something now, maybe using those same social networks to organize.

This was a hard decision. I spent two years of my life working with my own planning firm and the Cincinnati re-vitalization CDCs on making Cincinnati a better place to live and work. The entire business plan of the company I started was based on this as it’s goal, and enabling others to do the same. I would sit on the boards and the committees where the statistics of the “brain drain” that Cincinnati was experiencing were laid out; and we all were filled with desire to make Cincinnati a “cool city” again. I lamented when other young professional friends I had left the city. I volunteered with the United Way’s Emerging Leader’s group and tried to get young urban professionals interested in volunteer opportunities with the Red Cross Disaster Services team. Leaving, I always saw, was a sort of giving up. A failure.

However, even though the city has shown progress on re-vitalization downtown and in other areas, I can’t ignore the steady decline in this city of both population and opportunities that it and many mid-west cities are experiencing. I was getting worried back in 2005 when the economic numbers out of the region weren’t doing well, with a 3.5% growth rate and sad .04% job growth rate (while by comparison the rest of the country was growing at 4.0%). On the health front, smog alerts have become the norm and Cincinnati’s air quality was only rated good 48% of the time, while Seattle (while certainly not the highest of the nation) was at 70%. Cancer mortality is also 173.1 per 100,000 households in Seattle, vs. 237.3 in Cincinnati. Cardiac deaths are 165.6 vs. 275.4, respectively.

None of this matters as much as the quality of life and opportunity that Seattle and the West Coast offers, and I am extremely excited to be working for SAFECO doing the same work that I’ve been doing with Midland and others in the past: building the best financial services architecture in the industry. I’m certain we will.

Although I do not like leaving my remaining friends in the area, I have watched for too many years as my friends and colleagues have left for bluer skies and better opportunity. I do believe Cincinnati has some life in it yet, and the mid-west in general, but not enough for me or my family to have the opportunities I want to provide for them.

The bluest skies you’ve ever seen are in Seattle. And the hills the greenest green, in Seattle.

Below is an interactive slideshow of my talk given at the IBM Rational conference in 2007 entitled “From Legacy to Service-Oriented Architecture: The Strategic Importance of Services in the Insurance Industry”.

Synopsis: The insurance industry is one of the most complicated industries to manage from an IT perspective. Its complex and highly regulated business rules, as well as its early adoption of mainframes in the 80s and 90s, has led to a significant hurdle in moving existing infrastructures to a Service-Oriented Architecture (SOA). This session shows how the use of IBM Rational tools and IBM(R) Websphere(R) Process Server can free the industry from the complexities of implementing state specific compliance and business workflows through modeling and mediation flows.

This is a presentation I created to describe how SDOs can be used in the Insurance enterprise space to provide sanity in the large and diverse messages. These are increasingly being passed around as Business Objects in a Domain architecture as companies move their old object patterns to a service based approach (I refer to it as servitized business objects).

If you are looking for my particular experience on how SDOs and the IBM EMF framework that contains them works against the large ACORD schema, you can find my critique of Websphere Process Server and ACORD here and the SDO design pattern plugin I wrote for Rational Software Architect here.

Click the image to view this presentation interactively.

You may get the full version in Quicktime Movie format or Microsoft Powerpoint format.

I get a lot of emails about my critique of IBM’s Websphere Process Server, mostly along the lines of this email:

I’ve sent this email to you a couple of months back but didn’t get any reply. just thought would try my luck again…

we’ve made some progress with WPS and identified what areas are less risky so we can use at least some of the product features. we’re now building a prototype that uses mostly human tasks and some processes wrapped around them and we expose this all via webservices. there’s some pain around versioning, BPEDB queries, security, etc but at least we’re making a progress and early indicators seem to be on a positive side. we have had a couple of IBMers on site for a week and they helped us somewhat to rejig the design and focus on the features that seem to work and would add most value

still would be extremely interested to find out if you have done more with the product since you blogged about it

Well, obviously for competitive and disclosure reasons I can’t spill the beans on where my current employer is, what they are doing or why they are doing it. With those hand-cuffs in full public display, I will effort a more general entry about the state of affairs of this odd stack IBM has built.

In order to understand IBM’s approach to Websphere Process Server, you have to understand SCA/SDO, the unholy combination that seems to be driving the SOA mythology as of late.

About SDOs

There are currently three different implementations of the SDO spec, including Apache’s Tuscany (the one I’m cheering for), IBM’s from their EMF project for Eclipse and the interesting EclipseLink from Oracle and Interface21 (when those two get in a room together you should listen). EclipseLink is more of a consequence of combining SDOs and JPA, however.

I’m extremely excited about SDOs in general, to the point that sometimes I sit on my deck and dream about them. I even write presentations about their architectural implications. SDOs are awesome things.

They are, in essence, disconnected DataGraphs of DataObjects from some source. This source could be relational databases, entity EJB components, JCA, XML pages, Web services, or a combination of them all.

They can be acted upon and changed, updated and deleted, transformed, even serialized and sent to other objects and then connected back to the original data source with a ChangeSummary() to boot. For a more detailed understanding, check out IBM’s Introduction To Service Data Objects.

This is what they do in a nutshell:

1) You have data in any form from anything: Databases, XML, text, anything (or a combination of them).
2) You feed that data in to a Service Data Object.
3) Things can get pretty loose in there, so you can impose an XSD to define the types or just create the model on your own as you feed data in.
4) You disconnect the SDO from it’s source.

SIDEBAR: Last year I wrote a design pattern for SDOs in Eclipse’s UML2 framework that you can import in to Rational Software Architect.

Now you can do anything with this thing. Change the data inside, add more things to it, remove things from it, serialize it and send it across the wire, query the data inside of it, introspect it, combine it with JPA and tell it to save itself away from it’s source, anything.

Imagine the implications.

Design Strategy: Using SDOs with POJOs

No longer do objects have to have a strong contract, or any contract at all besides taking a type of DataObject. Your Business Objects can introspect the object itself to see if there is data inside of the DataObject it requires to do a task, do work on your behalf, update the DataObject’s DataGraph with new information (or replace existing information), and pass that SDO right back. The calling object can ask for a ChangeSummary() to see what occured to the data in that object, act on that data, and send it right along again to another object. When you are finished passing it around, it can immediately turn back in to the XML or database row it was loaded from.

Your Business Objects can change, the data inside your DataObject can change, or be a totally different DataObject all together. As long as the Business Object can query to see if the data it cares about is in there nothing about the contracts between your objects need change. Further, because of the API that comes with the SDO spec, your object doesn’t really need to know anything about the DataObject it’s feeding data into or getting data from. It can work with the part of the DataGraph it needs in a hands-off way and be done with it.

Think of it from a automobile insurance Use Case:

Say that you had a document based webservice that took an automotive insurance policy. This automotive policy would have an XSD that ensured it contained the data necessary for a complete policy. That XML document, once received, would be loaded in to an SDO with the XSD which would “strongly type” the data inside the DataObject that was generated.

Now, imagine this policy was sent to the webservice for a claim to be issued. You could pass this new SDO in to a “claims” system to be processed. The contract for the Claims system is just an SDO (type DataObject). The Claims system would do a simple XPath query, or do a get() on some data that it expected any DataObject that would come in to the system to have (remember, the data inside does have querable types because it was loaded with an XSD). Technically, it could even introspect the SDO DataGraph to find the data it needed. Whatever.

It would probably want to get Customer Information, Units Insured, ect. It would then do it’s own thing looking up the coverages, the limits and going about process to start a claim.

After processing, it could then append it’s update to the SDO by inserting data back in to the DataObject. The DataObject would then be sent back to the webservice, which would change the SDO back in to the XML document (again, the XSD ensures compliance) and sent back to the ESB or some other thing, but now with information on the claim that was created for it.

Now, remember that the Claims system doesn’t really know or care that the SDO is a policy. In fact, the SDO really has no type at all. You could have policy information, a recipe for Apple Pie and an iTunes playlist in the SDO. As long as the Claims system can get the right data from the SDO, it’ll work.

You could just as easily send the Claims system an SDO that only has the data necessary for issuing a claim. You could also change the Claim system so that it requires more information from the SDO, or writes additional information to the SDO (say requirements change).

None of this need impact the contract or the SDO that gets sent to the system.

So essentially, this is what an SDOs used with POJOs alone gives us:

• Objects are loosely coupled
• Object’s data can be discovered at runtime through query
• Object’s contracts are data based, no types or tightly binding interfaces
• Object is protected from contract and interface changes in system
• Objects can be placed anywhere - maximum reuse
• Object can modify it’s types and data structure during runtime
• Object has no restriction on the data it can share
• Object is decoupled from the format and source the data came from
• Object automatically can roll back to the previous data state or act on changes

This is just the impact SDOs have on sharing data between objects. SDOs have much more up their sleeves, including transformations and mapping.

It’s easy to see how this would fit in nicely to the theory of an SOA architecture. If you could just push around self-contained datagraphs of dataobjects, disconnected for their source, and transform them, map them together or change them in to other types of data, a lot of the complexity of dealing with data in an SOA would be solved… or at least abstracted.

SDOs and Websphere Process Server

It’s helpful to keep in mind that all workflow engines (WPS, JBoss jBPM, BlueSpring’s BPM) is a movement of the business logic and process flow from inside the code to outside, and that can only mean better flexibility for organizations going forward, even if current architecture design patterns regarding Business Objects have to change and give up their power or expose it more freely for orchestration (Fowler be damned).

The most intriguing thing about WPS, or any modern workflow engine, is the idea of visually managing the flow and business logic of services in an SOA. WPS promises to separate this orchestration from any code (save the code that it generates) and mix in human tasks to boot.

Workflow tools can be great when you have an Enterpise Service Bus or other solution where you have data flows coming at you from different technologies and different protocols that you want to feed in to a workflow. When you pull in a webservice or other Type that WPS supports in to it’s grahical tool, Websphere Integration Developer, it essentially reverses these data streams or objects in to strong types that are represented visually so that you have common base on which you can orchestrate, transform, and map the data between the various other imported flows. It’s easy to see how it leverages SDOs to do this, as it’s essentially what SDOs are best at. Mapping between these things and orchestrating them are easier if you have an abstract representation of the service or object.

The idea of building an entire enterprise from the ground up with this product is intriguing. However, I doubt that any project already in motion could manage to migrate from business logic in code to business logic in a product without significant rework, and the consultants specializing in WPS (and they are starting to emerge) seem to only have experience starting from scratch and in projects with human interaction. Regardless, this orchestration is most likely where WPS has the most benefit. It’s idea of transformation and consuming of the documents in the mediation itself is where things break down.

In Websphere Process Server, IBM essentially decided to use SDOs to parse and transform any data that comes in to their system. They coupled this with their previous Websphere Business Integrator product (WBI) for business orchestration of the processes that use these SDOs, stapled on an ESB implentation, stuck a feather in it’s cap and called it Maccaroni.

A product being a webservice de-seriailizer, data mapper and transformer, workflow tool and process manager is what ultimately makes Websphere Process Server the strage beast it is, and is also a major source of it’s problems.

In the work I’ve have done with WPS from a purely transformation and webservice flow standpoint, I’ve have found it to be slow but it works. There has been significant problems with the limited amount of flexibility WPS has in processing XML, managing messages and executing processes. IBM pitches that with WPS/WID business analyst or architects would be the ones that would do the mapping and process orchestration using visual tools. Often, however, we have been forced to fall down past the level of abstraction that WPS provides down to the Java code itself, which that is a sign of, if not failure, then immaturity.

Also, Websphere Process Server’s IDE where this mapping takes place visually, Websphere Integration Developer, is (since it is built on top of the Rational/Eclipse platform) hard for non-programmers to grasp; the idea of having to switch perspectives in Eclipse is foreign and unhelpful.

Ye Ol’ Impedance Mismatch

Unfortunately, even when you do go down to the Java level, things aren’t easy.

There are many times that what a WSDL specifies (compliant XML mind you) as a certain “type” and what “type” WPS renders for it are totally incompatible. For XSD:ANYTYPE, it dies flat out. However, so does any WSDL2Java tool. To combat this, code that was using the Collections framework has to be migrated to fixed length arrays so that WPS can interpret the output, as it sees any List as “AnyType”

Certainly, this type mis-match is experienced whenever one jumps from objects to documents in representing data (JSON anyone?), but that just points to the enormity of the problem WPS is trying to solve, and how trying to reverse XSDs without developer intervention is painful and filled with problems.

My Update

So, my update is that it still is not delivering on it’s promises, yet. However, I have heard from IBM that version 7, based off the Rational 7 (Eclipse 3.2) platform should be out in August / September.

I hope the reply was worth the wait.

I have been asked to present my work: “The Future of ACORD: Using Data Standards In The Semantic Web” at the Insurance Industry’s major conference ACORD-LOMA Insurance Systems Forum from May 20th - 22nd at the Dolphin Resort at Disney World. Since Microsoft and IBM are platnum sponsers, I’m expecting lots of free stuff At least, more than you get speaking at the Rational Conference.

I have included the detailed snippet from the brochure below, and more information about when I’m scheduled should appear on the website after February 2nd when I deliver all my media information (my head shots from junior high apparently don’t cut it anymore)

My primary thesis is how to use the language in which we communicate, XML (here ACORD standard) and apply meta-data to enable us to gain insight and increase both human and machine understanding of the data we have, essentially helping us make better decisions. It’s easy to see how a system knowing what a policy or a named-insured is beyond just an XML tag can benefit decision making systems including competative rating and data mining for risk patterns in insurance. All of this is based off of using RDF and Ontologies (here developed for insurance) to make relationships between data. Imagine how much more valuable a data warehousing operation would be with this solution.

I think you’ll like it and I hope you can make it.

My question to you is: Do you think the industry is ready, having just now got up to speed with webservices and Service Oriented Architecture, to apply meta-data to our language? Although the benefits of making the semantic leap are real, is it realisitic in the near future?

My Presentation Brochure Detail Snippet

XML, as a describer and standardization of data and datatypes, are changing as we move in to a future where humans won’t be consuming data as much as other computers will. The Semantic web is about metadata, or “data about data” that tells computers what type of data it is, and it’s context. It is about a language for recording how the data relates to real world objects. This allows a person, or a machine, to start off in one database, and then move through an unending set of databases which are connected not by wires but by being about the same thing.

For the insurance industry, this transformation can bring incredible advances and solutions to the problems we are experiencing as an industry that XML and webservices alone can’t solve, including managing large amounts of data and customer information. In the Semantic Web, for instance, we can know what products may interest a customer through relationships built from their CLUE reports and their preferences or send self-describing products to agents without any upfront setup. Most importantly, it can be used in data warehousing applications to allow insurance companies to create their own meaning from their customer data for better rating by deploying reasoning systems to determine what risks are related to what datasets deeper than ever before.

ACORD standards will play the lead in this, and companies that are adopting ACORD standards in managing their business communications now, especially using ACORD in their webservices, will have a lead in this advancement. ACORD can become “richer” when paired with RDF documents that not only enforce the standards, but describe them as well.

In my presentation, I will demonstrate the future value of deploying these reasoning systems, demonstrate the work I’ve done in developing reasoning systems for ACORD formatted data, demonstrate a sample using Firefox and MIT’s Piggy Bank plug-in (http://simile.mit.edu/piggy-bank/ ) of a future ACORD standard based website that will show a customer, the products they may like and the best rate; all from self-describing meta-data and without any code (only the data itself)

I work with MIT’s Semantic Web SIMILE (http://simile.mit.edu/) project as well as invented and run the opensource cl-semantic project (http://common-lisp.net/project/cl-semantic/ ) that uses Lisp to discover relationships between data for automatic processing and the realization of patterns, geared specifically towards insurance and other probability based businesses. I have also been involved in research creating a RDF version of the ACORD standards (the subset of Surety) to allow ACORD standards to be used in a Semantic Web demonstration. I am also an ACORD voting member of the Casualty/Surety working group and sub-groups underneath. I am well known in the industry for my work, and you can browse my referred and non-referred research papers from my website (http://www.brandonwerner.com).

As the year draws to a close, I realize I haven’t been conference jumping as much as I use to, but did want to draw attention to a few places I will be presenting sessions for. If you are attending, be sure to say hello. More information on times when it becomes available.

ACORD LOMA Insurance Systems Forum
May 20 - 22nd 2007
Lake Buena Vista, FL
My Session: Future of ACORD: Using Data Standards In The Semantic Web

IBM Rational Software Development Conference 2007
10-14 Jun 2007
Orlando, FL
My Session: Websphere Process Server and SOA For Insurance

Much has been made about the purchase of Webify by IBM a few days ago, and for good reason. This is the first time that a large company has put it’s money where it’s SOA mouth has been all this time. Despite the enthusiasm such a purchase as created among the SOA community (especially smaller groups specializing in vertical markets such as Insurance), the bigger point this purchase makes is that despite all the marketing blitz and betting of the Enterprise Software market on SOA by large players, it’s the small players who seem to be doing it right. IBM, for it’s sake, has so far failed in it’s SOA products for specific industries, and it’s purchase of Webify demonstrates their weakness in developing their own custom SOA solutions.

Sadly, I have been in the position to experience this failure first hand.

I am currently neck deep in an Insurance SOA experiment with IBM as we speak, structured primarily around WPS (Websphere Process Server), SDO (Service Data Objects), Websphere Integration Developer IDE and all the rules engines you can imagine. In the SOA future, no matter what the business, business rules (BPEL) that drive the business processes in our environment will be the most important aspect of the Service Oriented Architecture. It is these mediation flows consuming and transforming messages on the ESB that give a large enterprise the flexibility that SOA promises in rapidly exposing and using services to respond to business needs. For an industry such as Insurance, the business rules and services are some of the most complex and highly regulated in the business world. In IBM’s SOA view, Websphere Process Server is the engine that combines Connectors, transformations of ESB messages and mediation flows all in one package. At least, that was the plan.

We were one of the first to attempt to use WPS in partnership with IBM, and we came in to the experiment with great enthusiasm. After all, insurance is a field ripe for taking control of complex business rules. However, some attempts we have made to stretch or conform WPS to our liking has met with failure on IBM’s side. This includes the following issues:

• Consuming SOAP with attachments to convert a message to a ESB compatible Business Object or SDO is not possible
• Consuming webservice messages not HTTP or other standard form is tedious
• Numerous .xx releases to WPS and its development environment, Rational Integration Developer, has been IBM’s usual reply to issues with service connectors and visual mapping of services to Business Objects*.

This isn’t to say IBM’s suite of products in the SOA space isn’t impressive. Their Integration Developer IDE, built on top of Eclipse in much the same way Rational Software Architect and Rational Application Developer are (indeed, it’s just a few extra plug-ins), is amazing in it’s ability to attempt to consume external webservices and transform them in to SDOs that are controlled through the use of BEPL through-out the synapse. The problem is that the technology isn’t quite working yet, something that is disappointing when SOA has already made such inroads in the marketplace.
To this point, we are scaling back our strategy of using WPS in our new SOA architecture until the product matures, a very sad real world lesson to the marketing websites and seminars IBM is currently pitching. Keep in mind we’ve not stepped outside of IBM’s technology ecosystem once so far, including using every single piece of Websphere branded application server and Component we can license.

Although I developed the architecture of the SOA migration, including an inventive strategy to wrap existing non-SOA capable services to create custom SDOs for our ESB (some of which is hinted at when I published my SDO pattern for Rational Software Architect), the primary pain has been experienced by our Integration Team who are trying to get Websphere Process Server and it’s various services to work according to our designs. It is here, in the constant PMRs with IBM in nose-bleed level support tiers, that we are getting the most reality.

Insurance, as I stated, is a tricky business to begin with, and IBM was right in realizing that when it came to this vertical market, it needed someone who knew what it was doing. However, given my experience with IBM’s SOA products to date, they are going to need much more help than Webify can provide.

* - “Business Objects” is IBM’s term for SDOs generated from messages in WPS. It does not conform to the idea of “Business Objects” from an architecture stand-point. At this point, we should probably rename BOs from Fowler’s viewpoint since it is widely mis-used.