Crazy thing number 1

Journal Zarf's Journal: Crazy thing number 1 7

Journal by Zarf on Thursday March 01, 2007 @10:59AM

SOA.

Service Oriented Architecture

I know you kids out there have been running around getting your eye-brows pierced and tatting your bodies with XML, but to us old fogies this SOA thing is quite surprizing. The idea that you can have a common data interchange language that is shared by all services and then mash-up the data into new applications... why that's the original promise of OOP! But, this time it will work.

Back in the day we had a problem. Not all machines put bits in the right order. And, the right order was "big-endian" order. Just the way you ... the human... reads his bits when he reads his alpha numeric cereal in the morning. The big bits go left, the little bits go right. But some of our machines were "little-endian" these evil little _personal_ computers were build with low byte left, high byte right. This was done apparently because when you pulled bytes from their memory registers you used a pop operation and when you finished with the bytes you used a push operation.

That meant that if you wanted to preserve endian order on data elements larger than word length (or one byte) you had to shuffle memory somewhere since you can't push and pop multiple items between two stacks and preserve their order without a third sorting stack. So the little PC's saved themselves lots of clock cycles by just letting bytes sit in memory in what ever order they came of the CPU in... which turns out to be upside down.

There's no problem if you have homogeneous data. For example an image that has all pixel data in it. All the data elements are going to be the same. You could have a header or waste pixel that should be FFEF but if the data gets scrambled it will read EFFF and now you know to unscramble the bits. But what if you have a complex type?

If you have an Object or a Struct you may have an int then a char with five characters, then a float, then a double. Now then, the bits might look like this on a big endian machine: CD30313233343500FFEC32ECFFEC3210123C3210 and like this on a little endian machine: CD30313233343500EC32ECFF10323C121032ECFF ... no problem right? Just flip those bits around and get 30CD32313433003532ECFFEC3210123C3210FFEC ... wait that doesn't look right does it?

big : CD 30 31 32 33 34 35 00 FFEC32EC FFEC3210123C3210
little: CD 30 31 32 33 34 35 00 EC32ECFF 10323C121032ECFF

Bits are only flipped around on the little endian machine in the float and the double. That's because the float and the double are primitive data entities over one byte in size. (we're assuming a one byte word size) So when they get put onto stack they are going in one byte at a time in reverse order... and only the float and the double have this problem.

Don't forget we even have the potential for different programming languages on different computers over a network to need to send and receive these bits. So what's the answer? Someone tried enforcing "network" byte order. Someone tried to create an entire framework. Something named CORBA came into being.

CORBA was amazing it had all this messaging over-head and would marshall and unmarshall data through these things called IDL that would describe a universal bit pattern for an object. Wow. You would use the IDL to hang C structs, Java object or whatever off of a CORBA core. And it all worked over the network transparent to the programmer. So why aren't we all CORBA programmers today?

CORBA sucks. Yes I know that the real reason CORBA failed is political. The standards body produced paper instead of product and just assumed that real world programmers would read the papers and say: "wow, I should write that!" but CORBA sucks fundamentally. CORBA sucks because you end up writing the same thing over and over in each language you need to use that damn IDL in. And if you change an IDL in one place you change it everywhere... that sucks. CORBA sucks because its data output isn't human readable... and it sure isn't machine readable unless you have all the right CORBA bits running.

But there's hope.

Notice that the int and the characters are completely unperterbed. Wouldn't it be nice if we just represented all data as strings turning them into more complex types when needed?

The old skool 'nix hackers wrote everything to output text and operate on text. Everything was a file. Including nothing. Text didn't get perterbed by getting shot through the network, munched by a little endian machine, then shot at a big endian solaris box. So why not do CORBA all in text?

Bandwidth.

But today in the 21st century we have lots of bandwidth and our software all have a universal zip and unzip compression that can be turned on at both ends.

Enter SOA. SOA is the same basic idea except we use XML as our universal data format. XML is composed of nice 8 bit single byte values. No machine on earth will screw up the pretty 8 bit streams. The problems are parsing overhead and a common standard. These are solved by the defacto SOAP standard (thank you Microsoft) and the fact that parsing XML is no big deal for your gigahertz processor.

So old skool Unix wisdom hits 21st century CPU horse power and bandwidth and you have a solution that is both human readable, machine parsable, and hardware agnostic. SOA, SOAP, and XML aren't crazy new... they evolved from old skool unix hacker wisdom and corporate standards body governance working together. That's why SOA will really work this time. No really. It's just 1960's techniques with 21st century know how and everybody on the band wagon.

And that's just crazy thing number 1 I've got a few more crazy things to introduce... and then we'll put them in a blender with a frog and see what we get. You with me?

This discussion has been archived. No new comments can be posted.