Pages

Showing posts with label interfaces. Show all posts
Showing posts with label interfaces. Show all posts

Friday, May 16, 2008

More on COTS vs custom software

Lausanne Flon Copyright 2002-2008 A. Barake
It has been my experience that integration and associated maintenance of commercial off-the-shelf software (COTS) is an expensive and difficult process due to a few factors:
  • The "normal" upgrade cycle for vendors is often strategic and is driven by internal rather than external compatibility – upgrades also tend to break interfaces regardless of intent, it just does not help that the intent to play well with others is often at odds with large company policies (i.e. marketing strategy), especially when their suite of products covers many functional domains
  • Integration requires glue, and glue can either be COTS or home grown. For COTS, see above objection, and add cost. Home grown defeats the argument of using COTS in the first place Q.E.D.
Now, if we look at home-grown software, we have a few things to consider:
  • Maintenance is dependent on knowledge, but unless you are writing in APL  (and even then), the pool of developers with expertise usually exists; reading code and fixing it is what they are hired for and have some training in.
  • Developers in my experience much prefer to work on code where the source is available than integrate stuff using configuration and proprietary tools where the options are limited and the dependency on documentation and vendor support is limiting
  • Code is now pretty much commoditized except in specialized areas (telephony switching, military stuff, embedded stuff) and even then… there are only a handful of approaches that people use to write and maintain code and most good developers can immerse themselves in a code base within days of weeks and make it their own.
  • Renewal is key, and owning a system and renewing it by adding features is easier with home grown that has few integration points with COTS than with disparate COTS on different version cycles with glue in between.
The standards efforts are a sort of socialist (Stalinist really) approach to trying to control the ecological process described above, but is thwarted by vendor power struggles and the usual embrace and extend strategies, coupled with purchasing power in the hands of non-detail oriented people (i.e. not tecchies).

UNIX and other open system approaches have and are trying to tackle the problem through factoring out of common functional requirements into modular technical modules and protocols, and have had some success in advancing the state of the art – the Internet and its associated protocols and services are a direct result. The OSI stack is a manifestation of this approach and has become a pattern of understanding outside that world.

One approach is to layer the commercial stuff and isolate it from other commercial stuff through standard gateway mechanisms, off the shelf if you like, and these include queues, UNIX gateways and subsystems that use HTTP, SMTP and LDAP, xDBC as well as XML protocols where practical and where translation mechanisms are easy to obtain (message brokers, AJAX, browsers, SAML…) At another level we should be writing our own application code to use these underlying systems and the glue should be at the application level – i.e. SOA – services are COTS with standardized interfaces, applications are not.

Monday, April 14, 2008

Les mots

A Baja beach, bay side, Copyright 1988-2008 A. Barake

I was asked by my son about the meaning of the word "load". The context was "load the car". As I explained, by giving an example ("load the bags in the car"), I realized that the example provided an instance that could be generalized, but that was inherently ambiguous outside the continuity of experience. One has to have loaded things to understand that bags are just things, and we can extend the concept, and then we can even go further and talk about "a load" as a thing that is "loaded", without ending up in an infinite recursion.

You know where this is going...

Machines need to have exact mappings of symbols to "actions". Actions are just other symbol manipulations. So we have mappings and more mappings and rules and context and all the fodder of Minsky-type AI. Not good enough it seems. Gelernter and others have realized that one must be embedded in experience to have "knowledge". Husserl and Heidegger said it much earlier, but disciplines rarely cross. So we are realizing now that cognition is a sort of misnomer, we need a word to talk about "knowing", or better still "questioning" to get to a model of reality that is useful.

All this can lead to better and more flexible interface design for a start. Imagine a handshake that allows systems to agree on field semantics and field syntax for data exchange without all that WSDL baggage. Give me a couple of ports and go for it. Virus and spyware writers are now writing the primordial soup that will lead to these higher organisms one day.

Monday, November 26, 2007

More on automated interfaces

  • UNIX philosophy of universal read, write, create (sic), seek verbs is akin to financial transactions, where bytes are analogous to money
  • HTTP extended this with POST and made it stateless - so it becomes a client-server protocol (a good alternative to X-Windows by the way)
  • The universal currency is data, and it can contain anything, it can buy anything. Putting meaning to it is really the difficult part, and the notion of objects is really an attempt at creating a philosophy of data
  • Right now we have an inflation of data, too much currency, and its value is being balkanized, some currencies are more precious than others, security related ones, and maybe some video or music bytes. Copyright is an attempt at increasing the value of bytes through currency control.
  • So if an object defines the methods we can use to manipulate it, then one way to have objects communicate more easily (ideally automatically) is to constrain what objects can do to a machine manageable set. This may not be much of a constraint, only one that promotes efficiency through consistency.
  • Or we can take the idea behind types to heart and have a huge catalog of types and ensure that they can play together - real types which map to useful objects
  • For example, a user at any terminal could drop select from a list of things like ADDRESS CHANGE, VALIDATE ID, SUBMIT CLAIM, BUY, COMPLAIN, CHANGE FIELD, etc
  • This is the "naked object" philosophy taken one step further. No need for a graphical interface, just a nice "no error" interface - where all choices that work are shown. The "trie" of possibilities would reduce itself as transactions are chosen to interact, limiting the choices the more you decide
  • In short, modeling. Can this work in an ad-hoc world? Maybe the modeling should be automated through affinity and tuple-space approaches to ad-hoc property lists
  • This, coupled with a hierarchy of state machines (like game play AI) would go a long way to creating automated interface coupling.