Error Responses

Schema can be found here.

This section provides reference information about a common error format and recommended error codes[1] and process. Figure 1 shows a generic synchronous web-service call with either a fault response or a message response (but not both).

Figure 1

REST Error Responses

When there is an error, the header information contains:

Content-Type: application/xml
An appropriate 3xx, 4xx, or 5xx HTTP status code

The body or the response also contains information about the error. The following sample error response shows the structure of response elements common to all REST error responses.

<?xml version="1.0" encoding="UTF-8"?>
<Error>
  <Code>NoSuchKey</Code>
  <Message>The resource you requested does not exist</Message>
  <Key>
    <Id>123456</Id>
  </Key>
  <RequestId>4442587FB7D0A2F9</RequestId>
</Error>

A detailed composite key with URI references is shown below. The namespace is optional in REST depending on validation techniques.

<?xml version="1.0" encoding="UTF-8"?>
<Error xmlns="http://api.taybiz.com/core">
  <Code>NoSuchKey</Code>
  <Message>The resource you requested does not exist</Message>
  <Key>
    <Id uriRef="http://www.whatever.com/MAXIMOv6/PR#ORGID">TAYBIZ</Id>
    <Id uriRef="http://www.whatever.com/MAXIMOv6/PR#SITEID">COLORADO</Id>
    <Id uriRef="http://www.whatever.com/MAXIMOv6/PR#PRNUM">123456</Id>
  </Key>
  <RequestId>4442587FB7D0A2F9</RequestId>
</Error>

The following table explains the REST error response elements
[table]
Name,Description
Error,”Container for all error elements.”
Error/Code,”The error code is a required string that uniquely identifies an error condition. It is meant to be read and understood by programs that detect and handle errors by type. For more information, see List of Error Codes.Type: String”
Error/Message,”The error message contains a generic description of the error condition in English. It is intended for a human audience. Simple programs display the message directly to the end user if they encounter an error condition they don’t know how or don’t care to handle. Sophisticated programs with more exhaustive error handling and proper internationalization are more likely to ignore the error message.Type: String”
Error/Key,Container for Key information that identifies the resource or object that is involved in the error.
Error/Key/*Id,”The Id contains a piece of information to connect the subject of the error to the messaging system, GUI, or logging system. A Key has at least one Id and can have many to support spanning or composite keys.Type: String”
Error/Key/*Id/@uriRef,”An optional URI used to differentiate Id values.”
Error/RequestId,”An optional identifier that ties the request and error to the system that threw the error. This is often a GUID or UUID.Type: String”

[/table]
Many error responses contain additional structured data meant to be read and understood by a developer diagnosing programming errors. For example, if you send a Content-MD5 header with a REST PUT request that doesn’t match the digest calculated on the server, you receive a BadDigest error. The error response also includes as detail elements the digest we calculated, and the digest you told us to expect. During development, you can use this information to diagnose the error. In production, a well-behaved program might include this information in its error log.

SOAP Error Responses

In SOAP, an error result is returned to the client as a SOAP fault, with the HTTP response code 500. If you do not receive a SOAP fault, then your request was successful. The SOAP fault code is comprised of a standard SOAP 1.1 fault code (either “Server” or “Client”) concatenated with the organization-specific error code. For example: “Server.InternalError” or “Client.NoSuchResource”. The SOAP fault string element contains a generic, human readable error message in English. Finally, the SOAP fault detail element contains miscellaneous information relevant to the error.

For example, if you attempt to delete an object which does not exist, the body of the SOAP response contains a “NoSuchKey” SOAP fault.

The following example shows a sample SOAP error response.

<soapenv:Body>
  <soapenv:Fault>
    <Faultcode>soapenv:Client.NoSuchKey</Faultcode>
    <Faultstring>The specified resource does not exist.</Faultstring>
    <Detail>
      <Error xmlns="http://api.taybiz.com/core">
        <Code>NoSuchKey</Code>
        <Message>The resource you requested does not exist</Message>
        <Key>
         <Id uriRef="http://www.whatever.com/MAXIMOv6/PR#ORGID">TAYBIZ</Id>
         <Id uriRef="http://www.whatever.com/MAXIMOv6/PR#SITEID">COLORADO</Id>
         <Id uriRef="http://www.whatever.com/MAXIMOv6/PR#PRNUM">123456</Id>
        </Key>
        <RequestId>4442587FB7D0A2F9</RequestId>
      </Error>
    </Detail>
  </soapenv:Fault>
</soapenv:Body>

The following table explains the SOAP error response elements

[table]
Name,Description
Body/Fault,”Container for error information.”
Body/Fault/Faultcode,”The fault code is a string that uniquely identifies an error condition. It is meant to be read and understood by programs that detect and handle errors by type. For more information, see List of Error Codes.”
Body/Fault/Faultstring,”The fault string contains a generic description of the error condition in English. It is intended for a human audience. Simple programs display the message directly to the end user if they encounter an error condition they don’t know how or don’t care to handle. Sophisticated programs with more exhaustive error handling and proper internationalization are more likely to ignore the fault string.”
Body/Fault/Detail,”Container for the key involved in the error”
Body/Fault/Detail/*Error,”Identifies the information involved in the error; see the REST interface Error object for definition. The Fault element allows for an unbounded list of elements; a single error is expected. If many are sent agree on a limit to keep this payload small.”
[/table]

The following table lists generic error codes. Custom application should use process-specific codes; however, do not overwrite or redefine these below.

List of Error Codes

[table]
HTTP Status Code[2],”Error Code”,”Description”,”SOAP Fault Code Prefix”
“301 Moved Permanently”,”PermanentRedirect”,”The resource you are attempting to access must be addressed using the specified endpoint. Please send all future requests to this endpoint.”,”Client”
“307 Moved Temporarily”,”Redirect”,”Temporary redirect.”,”Client”
“400 Bad Request”,”BadDigest”,”The Content-MD5 you specified did not match what we received.”,”Client”
“400 Bad Request”,”CredentialsNotSupported”,”This request does not support credentials.”,”Client”
“400 Bad Request”,”EntityTooLarge”,”Your proposed upload exceeds the maximum allowed object size.”,”Client”
“400 Bad Request”,”EntityTooSmall”,”Your proposed upload is smaller than the minimum allowed object size.”,”Client”
“400 Bad Request”,”ExpiredToken”,”The provided token has expired.”,”Client”
“400 Bad Request”,”IncompleteBody”,”You did not provide the number of bytes specified by the Content-Length HTTP header”,”Client”
“400 Bad Request”,”IncorrectNumberOfFilesInPostRequest”,”POST requires exactly one file upload per request.”,”Client”
“400 Bad Request”,”InlineDataTooLarge”,”Inline data exceeds the maximum allowed size.”,”Client”
“400 Bad Request”,”InvalidArgument”,”Invalid Argument”,”Client”
“400 Bad Request”,”InvalidResourceName”,”The specified resource is not valid.”,”Client”
“400 Bad Request”,”InvalidDigest”,”The Content-MD5 you specified was an invalid.”,”Client”
“400 Bad Request”,”InvalidRequest”,”SOAP requests must be made over an HTTPS connection.”,”Client”
“400 Bad Request”,”InvalidSOAPRequest”,”The SOAP request body is invalid.”,”Client”
“400 Bad Request”,”InvalidToken”,”The provided token is malformed or otherwise invalid.”,”Client”
“400 Bad Request”,”InvalidURI”,”Couldn’t parse the specified URI.”,”Client”
“400 Bad Request”,”MalformedError”,”The XML you provided was not well-formed or did not validate against our published schema.”,”Client”
“400 Bad Request”,”MalformedPOSTRequest”,”The body of your POST request is not well-formed multipart/form-data.”,”Client”
“400 Bad Request”,”MalformedXML”,”This happens when the user sends a malformed xml (xml that doesn’t conform to the published xsd) for the configuration. The error message is, “The XML you provided was not well-formed or did not validate against our published schema.””,”Client”
“400 Bad Request”,”MaxMessageLengthExceeded”,”Your request was too big.”,”Client”
“400 Bad Request”,”MaxPostPreDataLengthExceededError”,”Your POST request fields preceding the upload file were too large.”,”Client”
“400 Bad Request”,”MetadataTooLarge”,”Your metadata headers exceed the maximum allowed metadata size.”,”Client”
“400 Bad Request”,”MissingRequestBodyError”,”This happens when the user sends an empty xml document as a request. The error message is, “Request body is empty.””,”Client”
“400 Bad Request”,”MissingSecurityElement”,”The SOAP 1.1 request is missing a security element.”,”Client”
“400 Bad Request”,”MissingSecurityHeader”,”Your request was missing a required header.”,”Client”
“400 Bad Request”,”RequestIsNotMultiPartContent”,”Resource POST must be of the enclosure-type multipart/form-data.”,”Client”
“400 Bad Request”,”RequestTimeout”,”Your socket connection to the server was not read from or written to within the timeout period.”,”Client”
“400 Bad Request”,”TokenRefreshRequired”,”The provided token must be refreshed.”,”Client”
“400 Bad Request”,”UnexpectedContent”,”This request does not support content.”,”Client”
“403 Forbidden”,”AccessDenied”,”Access Denied”,”Client”
“403 Forbidden”,”AccountProblem”,”There is a problem with your account that prevents the operation from completing successfully.”,”Client”
“403 Forbidden”,”InvalidAccessKey”,”The Access Key you provided does not exist in our records.”,”Client”
“403 Forbidden”,”InvalidObjectState”,”The operation is not valid for the current state of the object.”,”Client”
“403 Forbidden”,”InvalidPayer”,”All access to this object has been disabled.”,”Client”
“403 Forbidden”,”InvalidSecurity”,”The provided security credentials are not valid.”,”Client”
“403 Forbidden”,”NotSignedUp”,”Your account is not signed up for the service.”,”Client”
“403 Forbidden”,”RequestTimeTooSkewed”,”The difference between the request time and the server’s time is too large.”,”Client”
“403 Forbidden”,”SignatureDoesNotMatch”,”The request signature we calculated does not match the signature you provided. Check your signing method.”,”Client”
“404 Not Found”,”NoSuchResource”,”The specified resource does not exist.”,”Client”
“404 Not Found”,”NoSuchKey”,”The specified key does not exist.”,”Client”
“404 Not Found”,”NoSuchUpload”,”The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.”,”Client”
“405 Method Not Allowed”,”MethodNotAllowed”,”The specified method is not allowed against this resource.”,”Client”
“409 Conflict”,”ResourceAlreadyExists”,”The requested resource name is not available. Please select a different name and try again.”,”Client”
“409 Conflict”,”ResourceNotEmpty”,”The resource you tried to delete is not empty.”,”Client”
“409 Conflict”,”InvalidResourceState”,”The request is not valid with the current state of the resource.”,”Client”
“409 Conflict”,”OperationAborted”,”A conflicting conditional operation is currently in progress against this resource. Please try again.”,”Client”
“411 Length Required”,”MissingContentLength”,”You must provide the Content-Length HTTP header.”,”Client”
“412 Precondition Failed”,”PreconditionFailed”,”At least one of the preconditions you specified did not hold.”,”Client”
“416 Requested Range Not Satisfiable”,”InvalidRange”,”The requested range cannot be satisfied.”,”Client”
“429 Too Many Requests”,”SlowDownClient”,”Please reduce your request rate.”,”Client”
“500 Internal Server Error”,”InternalError”,”We encountered an internal error. Please try again.”,”Server”
“501 Not Implemented”,”NotImplemented”,”A header you provided implies functionality that is not implemented.”,”Server”
“503 Service Unavailable”,”ServiceUnavailable”,”Please reduce your request rate.”,”Server”
“503 Slow Down”,”SlowDownServer”,”Please reduce your request rate.”,”Server”
[/table]

[1] Heavily influenced by Amazon Web-Services.

[2] HTTP Status codes from Wikipedia, 6/27/2013: http://en.wikipedia.org/wiki/List_of_HTTP_status_codes

[3] http://www.oracle.com/technetwork/articles/soa/luttikhuizen-fault-handling-1-1877036.html (not directly referenced but a good general read)

I finished out a contract last week with Comcast.

Mostly this included breaking out the ORAMDS dependencies in a large bundle of Oracle BPM Suite 11g code.

I converted the BPM and SOA Suite builds to Maven 3.3.x, created Jenkins slave nodes for building, and connected to Artifactory for deployment.

Documentation was created, converted, or enhanced using Markdown at first, but finished up using asciidoc. I even had a chance to contribute to one of the maven-asciidoctor plugins.

For any component that exposes a WSDL-based endpoint (WADL too for that matter), create an inline (i.e., flattened ), abstract (i.e., no service endpoint defined) WSDL and attach it as an artifact using Maven or Gradle.

This WSDL can then be used by upstream systems for design-time resolution with or without the target system being online. This is particularly useful for systems across multiple environments. A common practice seen in the wild is to use the development WSDL in tools like Oracle SOA Suite, SoapUI, WSO2 ESB, etc. But then those systems are development and not running all the time.

Alternatively some use the production WSDL but use the concrete WSDL with the production endpoint. If your services are not tightly secure — you know who I’m looking at! — this can be a bad thing when test data starts to flood over into production endpoints.

Below is an example XSLT to flatten a WSDL. This version leaves out comments — though you might want yours in — and also removes “plnk” nodes from the XML. The latter are Oracle SOA Suite specific and shouldn’t be in an abstract WSDL. The xmlns:plnk entry remains and I could never quite get that gone.

<?xml version="1.0"?>
<xsl:stylesheet version="2.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:plnk="http://docs.oasis-open.org/wsbpel/2.0/plnktype"
    exclude-result-prefixes="plnk"
>
 
    <xsl:output version="1.0" encoding="utf-8" indent="yes" name="xml" />
 
    <xsl:template match="/">
        <xsl:apply-templates />
    </xsl:template>
 
    <xsl:template match="xsd:schema">
        <xsl:copy-of select="document(xsd:import/@schemaLocation)" />
    </xsl:template>
 
    <xsl:template match="@*|node()">
        <xsl:copy>
            <xsl:apply-templates select="@*|node()" />
        </xsl:copy>
    </xsl:template>

    <xsl:template match="plnk:partnerLinkType"/>
    <xsl:template match="comment()"/>
</xsl:stylesheet>

* Credit to Github for pointing me the right direction.

Below is an example of a Maven antrun task that executes the XSLT. I chose antrun because I was converting SOA 11g builds to Maven… and I was solidly in antrun’s world anyway.

            <plugins>
    <plugin>
        <artifactId>maven-antrun-plugin</artifactId>
        <version>1.8</version>
        <executions>
            <execution>
                <id>sca-package</id>
                <phase>package</phase>
                <goals>
                    <goal>run</goal>
                </goals>
                <configuration>
                    <target name="package">
                        <!-- flatten the exposed WSDL. This can change from project to project because each WSDL is named differently. -->
                        <xslt in="ExampleProcessBPEL.wsdl"
                            out="${project.build.directory}/ExampleProcessBPEL.wsdl"
                            style="src/main/resources/flattenWSDL.xslt"/>
                        <attachartifact file="${project.build.directory}/ExampleProcessBPEL.wsdl" type="wsdl" />
                    </target>
                </configuration>
            </execution>
        </executions>
    </plugin>
</plugins>

There’s a point in every consultant’s professional life where he or she has to make a decision, take a stand. And while it’s not food security, prison reform, or world peace, starting with Oracle ADF is at least one place to start. We don’t support it, try not to take gigs that work with it, and ultimately would like you to do the same.

For the last six months I’ve received at least one recruiter call a week asking if we’re interested in a “very exciting” opportunity to work with Oracle ADF reasonably near us. Then they sweeten it by saying it’s for a large consulting operation (but actually for a contractor to said large consulting group). And then to make it even more attractive it’s for the Federal government. The most recent recruiter got way more than she was expecting… and I was surprised also by my forcefulness re ADF. So I felt I should write it down more rationally for future reference.

The bottom line is that every job I’ve worked with ADF has been at best an “intro to J2EE or EE5” programming class best suited for a community college evening class setting, not for professional work. We build something up and so long as the layout is super simple and easy to modify fonts and colours, everything stays together. But the kit falls apart the very first time things need to be really understood, taken apart.

This isn’t a bash against the corporate developers. It’s just they are usually neither interested in nor passionate about developing large code bases with complex dependency management. These hard-working souls are Microsoft .NET programmers at heart and really just want to build the thing in VB.NET. And they’re right to think that way. I’m not beating up on .NET developers here. I know a number of places that run very smoothly, very well indeed on Visual Studio-written code. These people couldn’t build code from the command line if their very lives depended on it… and they are still wonderfully productive and successful.

I think the developers are generally split into two camps (I know… not an original thought): those who want to understand the stack deeply and those see the stack as a distraction to the “real work”. I do not think either camp is wrong. Oracle’s ADF is a stack that competes directly with .NET, not stacks like Ruby on Rails, Grails, or Meteor. Which begs the question why not just use .NET? You can’t swing a dead cat around a user’s group meeting without hitting a .NET programmer. Oracle ADF folks? Federal, state, and local government developers mostly (read: $$$$). The U.S. Government seems to love Oracle ADF (I’m looking at you, Department of Interior) which should immediately tell you at least something.

There’s also an open-source issue in all of this, but again it comes down to FOSS offerings such as RoR, Grails, JS-based stacks v. closed-source goods such as Oracle ADF and .NET-based frameworks. Which goes back to the main point. Use .NET if you insist on closed-source. You’ll be happier and have less to “explain up the chain” as to why your project is so mugged.

What I’m not doing is bashing JDeveloper. I think it’s probably one of — if not the — best XML editors out there. I like it, I know it well, and I’ve used it for coding other than Oracle products. Eclipse it is not. And every now and then there are good reasons to not use Eclipse. Really.

A question came up recently about using canned schema models like NIEM, OAGIS, HRXML, cXML, etc. I posted the following thoughts in response:

I sat on the OAGIS 10 working group for a short while so I have some insight specifically into OAGIS, but I can also speak to using other schema such as cXML, NIEM, and others.

I find it useful for this to break up the dialects into levels [1].

1 – Atomic dialect. This is the lingo that the system speaks when you bought it or built it. Maximo speaks Maximo, PeopleSoft speaks PeopleSoft, Hank down the hall wrote it using Hank-speak. It is what it is.
2 – <Reserved> This layer is reserved for wrapping naked databases or bringing other funky systems up to the HTTP world.
3 – Domain dialect. These are the business dialects of the organization and it’s up to the organization to come up with something that is unsurprising to each other (Principal of Least Surprise).
4 – Enterprise. This is where the edge of your company meets another company. And it’s here only that I would introduce a canned (e.g., OAGIS) schema.

Each of these levels should expect different namespaces, using your integration framework to convert E<->D<->A. The E-D is your enterprise service bus, and your D-A consist of one or more domain busses.

My experience is that whoever pays the piper calls the tune. So for example if you’re communicating to the US Federal systems you’re going to use NIEM. If your business is >90% federal you might want to get good at NIEM so it’s worth bringing in house. Chemical houses like OAGIS so that just might be the thing to bring in house if you do lots of chemical business.

Inside your company domains (e.g., finance, hr, accounting, maintenance, procurement, parking, whatever) I think it’s very reasonable and maintainable to use your own common schema. This includes a complete and versioned namespace and I keep schema and validation rules in source control always.

I have created domain schemas on OAGIS before with mixed results. There are some limitations in modeling anything with XSD that are inherent in the root-tree structure of XML. One of the deepest rabbit holes I’ve seen folks fall into with OAGIS is the attempt to model reality with it. XSD is not a sufficient structure for ontological modeling.

OAGIS has a few issues. These are echoes of the below in any canned schema (take a look at HL7v3 or NIEM for some of the same woefulness, though at least NIEM brings CAM).

It’s not wonderfully tool friendly. So expect to get very very good at XSD debugging to get it to work. Your junior integrators and developers will dislike you intensely. So be ready for that.
It’s highly complex and sometimes doesn’t make immediate sense. So factor in a learning curve. Again exactly what do you think of your coworkers?
It’s not really what we think of today as “open”. That’s an artifact of history. OAGIS predates our recent (as of this writing) understanding of what “open” means. I think of open as “open source” and all that entails. At the bottom of it all OAGIS sells standards that they would like you to pay for (IEEE or ISO do it too). Unlike today’s understand of open source you can’t contribute and extend unless it’s within the constraints of their license. Pay attention to that.
It’s not a great implementation of its own standard. There was a small debate while I sat on the group about doing a better job of creating the business model (maybe RDF or an ontology-based approach). The idea would then be to express or generate the schema as a set of artifacts. This didn’t happen while I was there so the implementation was the model was the schema. If you buy into the idea that XSD is completely limited in its ability to model (that’s not what XSD is for anyway) then you can see where it will fail.

But what OAGIS does do is eliminate the fight. We’ve all been there. I add an element to a PurchaseRequisition called “OverlayField05” and we fight for weeks about why we didn’t call it “PurveyQualification” (those are made up!). When things look odd or strange you can all together blame OAGIS. And you will. The problem is you’ll likely be fighting each other for different reasons, along the line of “who made us use this canned schema?” Still one less fight is one less fight.

So maybe it comes down to the question of “Who made us use this canned schema?” If it is your chief architect, an external owning company, the federal government, or someone else with more muscle, then at least you know. I’ve often thought that these canned schema should come with prewritten letters to give to your managers apologizing for when the inevitable comes, and he or she wants to know why you’re so behind farting around trying to get the canned schema to work.

Finally I think the world has moved some in the last few years towards the API mentality that simply states that the edge of your application is _your_ edge. If you expose your services using a funky schema that’s what it is and the consumer is responsible for sucking it up. That consumer might _also_ be you, but change your hats, get a decent integration framework and keep on moving. I mentioned a tool above called CAM and it’s used a lot with NIEM. It’s not perfect but it forces the conversation of modeling versus API and is super helpful in a more API-centered world.

[1] I took the idea of the numbers for levels from chapter 12, Definitive Guide to SOA, Oracle Service Bus (Davies, Schorow, Ray, Rieber) but have modified the levels somewhat.

Taylor Business Solutions, Inc. (TBSI) has recently made the decision to no longer maintain domain registrations without associated paid web hosting. If we are not hosting your domain look for a letter before your domain expiration date explaining your options. It’s easy, it’s cheap to register a domain, and we’ll help you find a new home for your registration.

Thanks!

Here’s another filing under the heading, “Why aren’t my SOA initiatives working?”

I call it “Database Overreach” and it’s when an enterprise level ETL or SOA tool uses adapters to “reach over” and scoop information out — and worse, poke data back in to — a database. The number #1 indicator that you might be doing it is using database adapters of ETL/SOA tools such as Tibco, WebMethods, Oracle SOA Suite, &c.

Why is Database Overreach Bad

1. Moves the responsibility away from the owner of the database. For instance, if the app admin is responsible for the application he or she must be responsible for the database. The most common scenario however, is the integration folks become adjunct app admins: it’s very rare for the app admin to make the leap into XML, XSD, WSDLs, RESTful API, and the like. So what looks like the easy way is to skip it and connect straight to the database. Your app admin loses control of the app.

2. It may be because the database doesn’t have a front-end at all. I call this a “naked database” and it’s so loathsome I will write a different bit on that alone. There’s an unfortunate laziness in not creating a proper front-end for a database. Symptom of a naked database? When you have a near-dedicated person who is the only one who knows which special SQL/DML command to run to free up your payroll or un-screw the procurement processes.

3. It steals the opportunity for your database to become a member of your event- and service-enabled fabric. The whole point of using HTTP is lost by leaving the service exposed on port 1433 or 1521. Overprivileged user credentials, funky ports, vendor-specific interfaces. All bad.

[Aside, I’ll take this opportunity to say that an RDBMS exposed as native JDBC or ODBC is absolutely service-enabled (and therefore all perfectly “SOA”), but so is CORBA, and for that matter DCOM. There is a quality attribute to service design that becomes pretty important. Ultimately the point I hope to make is that RDBMS-exposed services are extremely low quality.]

What a bad pattern looks like

System A calls the super-dandy database adapter tool (e.g., Oracle Fusion Middleware, Tibco, WebMethods, JBoss, IBM, etc.).

The adapter tool uses fixed credentials and hard-coded information (point-to-point, brittle, hard to maintain over time) to reach completely over the API, the app, and directly into the application database.

[Show slideshow]

What To Do

Wrap your naked databases in an application API layer and bring it up to speed in the API world. Folks who sell tools like Oracle SOA Suite would have you think that’s what you’re doing. But I see a lot of places that use database adapters extensively then don’t undestand why the “SOA” is so inflexible and brittle. SOA Suite has a bold-case, underlined big #1 use case: long-running orchestration. For that, SOA Suite is amazing. Using it to match impedence between HTTP and JDBC? There are better ways, better “applicationist” ways.

My team and I have been standing up high-quality, highly-secure, and now cloud-published wrapper applications for years. Ask about how we can help you can start separating your database applications to improve reliability, resiliency, and to avoid the brittle “upgrade hell” path that comes that from too tightly coupling the database to your service-enablement tool.

From time to time in training sessions, work engagements, and social settings I refer to us as Applicationists. Not developers per se, not architects either. But people dedicated to building high-quality applications as the cornerstones of proper Event- and Service-enabled Architecture and Design.

It’s a principle of ours that all great integration starts from excellent applications. It’s not possible with naked databases, non-existent API, or sorry security. Back in “the day” creating applications was admittedly difficult to do for RDBMS-based systems. Today, however, is a different time. Grails, Ruby-on-Rails, .Net… these provide some of the fastest frameworks around to rapidly create high quality centres of application excellent to support SOA and EDA goals.

Applications have taken hold of our culture with the advent of iOS and Android apps of course. But they’ve never left the stage as core functions on the desktop. So while the latest way to refer to applications is “Apps”, what is spoken of here is to the larger “Application”.

An Applicationist Value Set

Applications are the center of excellent business and integration design.

An Application is how data-at-rest becomes data-in-flight.

Any application that can expose a high-quality API (e.g., HTTP/REST) must do so. Any application that cannot (e.g., Active Directory DS,, Oracle RDBMS, Microsoft RDBMS, etc.) must have an application written around it to expose a high-quality API.

Any application that is authoritative for information has the obligation to “event out” said information.

Applications are designed using design tenets of Messaging, Monitoring, and Security.

Applications are supported by the bureaucratic tenets of Design (Architecture), Process (Governance), and Construction (Development).