Eliminating web service dependencies with a language-specific abstraction barrier
Hyperbolic analogy: Saying, "You shouldn't need to wrap the web service interface, because it already provides an API," is like saying, "You shouldn't need different programming languages, because they're all Turing complete."
Web services tend to deliver raw data payloads from a flat interface and thus lack the usability of native language APIs. Inevitably, when you program RPC-like interfaces for no language in particular, you incur incompatibilities for every particular language's best practices, idioms, and data models. [*] The issue of appropriately representing exceptions and/or error codes in RPC-like services is a notorious example of this.
There are additional specification mechanisms like WSDL [†] that allow us to make the payloads more object-like. Additional structure is indicated through the use of user-defined "complex types," but this only gets you part of the way to a usable API for any given language. In Python, it's a lot more sensible to perform an operation like in the following abstraction:
from internal_tracker.service import InternalTracker bug_serivce = InternalTracker(username=getpass.getuser(), password=getpass.getpass()) bug = bug_service.get_bug(123456) bug.actionable.add('Chris Leary') # may raise ReadOnlyException comment = Comment(text='Adding self to actionable') bug.arbs.add_comment(comment) bug.save() # may raise instanceof ServiceWriteException
Than to use an external web service API solution directly (despite using the excellent Suds library):
# Boilerplate client = suds.client.Client(wsdl=wsdl_uri) security = suds.wsse.Security() security.tokens.append(UsernameToken(getpass.getuser(), getpass.getpass())) client.set_options(wsse=security) internal_tracker_service = client.service # Usage service_bug = internal_tracker_service.GetBug(123456) service_bug.actionable += ', Chris Leary' # Do we check the response for all WebFault exceptions? # (Do we check for and handle all the possible transport issues?) internal_tracker_service.UpdateBug(service_bug) Comment = internal_tracker_service.factory['Comment'] comment = Comment() comment.BugId = service_bug.Id comment.Text = 'Adding self to actionable' # Again, what should we check? internal_tracker_service.AddComment(comment)
Why is it good to have the layer of indirection?
Lemma 1: The former example actually reads like Python code. It raises problem-domain-relevant exceptions, uses keyword arguments appropriately, follows language naming conventions, and uses sensible language-specific data types that may be poorly represented in the web service. For example, actionable may be a big comma-delimited string according to the service, whereas it should clearly be modeled as a set of (unique) names, using Python's set data type. Another example is BigIntegers being poorly represented as strings in order to keep the API language-neutral.
Lemma 2: The layer represents an extremely maintainable abstraction barrier between the client and the backing service. Should a team using the abstraction decide it's prudent to switch to, say, Bugzilla, I would have no trouble writing a port for the backing service in which all client code would continue to work. Another example is a scenario in which we determine that the transport is unreliable for some reason, so decide all requests should be retried three times instead of one. [‡] How many places will I need to make changes? How many client code bases do I potentially need to keep track of?
Why is it risky to use the web service interface?
If the web service API represents the problem domain correctly with constructs that make sense for your language, it's fine to use directly. (As long as you're confident you won't have transport-layer issues.) If you're near-certain that the backing service will not change, and/or you're willing to risk all the client code that will depend on that API directly being instantaneously broken, it's fine. The trouble occurs when one of these is not the case.
Let's say that the backing service does change to Bugzilla. Chances are that hacking in adapter classes for the new service would be a horrible upgrade experience that entails:
Repeated discovery of leaky abstractions,
Greater propensity to bugs, [§] and
More difficult maintenance going forward.
Client code that is tightly coupled to the service API would force a rewrite in order to avoid these issues.
Pragmatic Programming says to rely on reliable things, which is a rule that any reasonable person will agree with. [¶] The abstraction barrier is reliable in its loose coupling (direct modeling of the problem domain), whereas direct use of the web service API could force a reliance on quirky external service facts, perhaps deep into client code.
Is there room for compromise?
This is the point in the discussion where we think something along the lines of, "Well, I can just fix the quirky things with a bunch of shims between my code and the service itself." At that point, I contend, you're really just implementing a half-baked version of the language-specific API. It's better to make the abstractions appropriate for the target language and problem domain the first time around than by incrementally adding shims and hoping client code didn't use the underlying quirks before you got to them. Heck, if the web service is extremely well suited to your language, you'll end up proxying most of the time anyway, and the development will be relatively effortless. [#]
What about speed of deployment?
If we have language-specific APIs, won't there be additional delay waiting for it to update when additional capabilities are added to the backing service?
First of all, if the new capability is not within the problem domain of the library, it should be a separate API. This is the single responsibility principle applied to interfaces — you should be programming to an interface abstraction. Just because a backing service has a hodgepodge of responsibilities doesn't mean that our language-specific API should as well. In fact, it probably shouldn't. Let's assume it is in the problem domain.
If the functionality is sane and ready for use in the target language, it should be really simple for the library owner to extend the language-specific API. In fact, if you're using the proxy pattern, you may not have to do anything at all. Let's assume that the functionality is quirky and you're blocked waiting for the library owner to update with the language-specific shim, because it's non-trivial.
Now our solution tends to vary based on the language. Languages like Python have what's known as "gentlemen's privacy", based on the notion of a gentlemen's agreement. Privacy constraints are not enforced at compile-time and/or run-time, so you can just reach through the abstraction barrier if you believe you know what you're doing. Yes, you're making an informed decision to violate encapsulation. Cases like this are exactly when it comes in handy.
assert not hasattr(bug_service, 'super_new_method_we_need') # HACK: Violate abstraction -- we need this new capability right now # and Billy-Bo, the library owner, is swamped! suds_client = bug_service._suds_client result = suds_client.SuperNewMethodWeNeed() target_result = de_quirkify(result)
As you can see, we end up implementing the method de_quirkify to de-quirk the quirky web service result into a more language-specific data model — it's bad form to make the code dependent on the web service's quirky output form. We then submit our code for this method to the library owner and suggest that they use it as a basis for their implementation, so that a) they can get it done faster, and b) we can seamlessly factor the hack out.
For privacy-enforcing languages, you would need to expose a public API for getting at the private service, then tell people not to use it unless they know what they're doing. As you can tell, you pretty much wind up with gentlemen's privacy on that interface, anyway.
In EE we call this kind of phenomenon an impedance mismatch, which results in power loss.
And many others, with few successful ones.
Or maybe we want to switch from HTTP transport to SMTP. Yes, this is actually possible. :-)
In duplicating exact web service behaviors — you have to be backwards compatible with whichever behaviors the existing client code relies on.
It's a syntactic tautology. The caveat is that reasonable people will almost certainly quibble over the classification of what's reliable.
At least in Python or other languages with a good degree of dynamism, it will.