On Thu, 2002-04-18 at 12:15, Ronan Heffernan wrote:
> The other "best we can do" is wrap the legacy stuff inside modern stuff.
> This is one of the big approaches/promises of CORBA. Take your legacy
> code and put individual units of functionality behind CORBA object
> methods, and you can develop modern OO software. Your wrappers are
> kind-of just translators, but you can designate them as part of the
> legacy code...one that plays well with modern tools and technologies.
Even CORBA is loosing ground now to newer SOAP/XML/... text solutions.
The best thing about Corba was the idea of a well defined CORBA IDL
interface. Unfortunately, CORBA adds a bit of complexity and perceived
headache for coders doing ad-hoc development.
The latest craze is to define XML DTDs and expose a programmatic SOAP
interfaces for code between boxes.
One is binary a triumph of efficient coding.
One is virtually ASCII, a direct decendant of SGML.
There's another common binary IDL you may be familiar with that is
wholely separate from the CORBA IDL: OSI ASN.1
> Similarly, we will probably see a CORBA wrapper (eventually) around the
> stop-light communication functionality. I did the same sort of thing
> with Electric Meters. A meter reported its energy usage by closing a
> relay for 20ms every time it recorded the expenditure of n kilowatt
> hours. Talk about a brain-dead protocol! My company put a little
> dollop of hardware and software near the meter that speaks TTL and
> CORBA. Now, talking to the meters is an Internet-aware OOP excersize!
Your KDE and GNOME desktops are fully CORBA (note the running orbit
daemon). Yes, you can integrate your desktop into your business systems.
Why don't you?... it's not particularly easy for a standard user to do
this yet (we still lack the simplicity of a Visual Basic type killer app
that made OLE COM Automation possible on Microsoft's platforms).
You are probably aware of the drive toward future GNOME development
leaning toward Microsoft C# with the Mono project (depending on who you
ask). It's evolution for the sake of simplicity, when you get right down
to it..
> I think that this kind of 'wrapping' is better than 'building backward
> compatibilities into new systems'. You could quibble and say that we
> *have* 'built backward compatibilities into new systems', but because
> the wrappers are stored and maintained as though they are part of the
> legacy system, and because we are not polluting our new solution with
> backward compatibility code, I see it differently.
Wrappers are not "backward compatibility", they are facades thrown up on
top of older code. By backward compatibility, I really meant porting the
old codebase to the new platform. Do you realize how much COBOL code and
IBM370 assembler resides behind any major business system at Verizon?
Sure, the GUI may be Windows based, but behind the scenes the client
station is communicating with an application gateway that calls MQSeries
interfaces that wrap functions exposed directly by mainframe native
code.
"Middleware" concepts like MQSeries is gaining acceptance. The old RPC
methods we're used to in the Unix world (as with Sun ONC RPC, Corba
DCE/IIOP, and now Soap XML/RPC) are ok for live real-time connected
processing, but not really for batch processing or load-sharing job
queues. The direction really needs to evolve back into XML message
queues with guaranteed delivery between SOAP (or other XML based
messaging) services.
Microsoft's COM architecture with the cludges that were DCOM and MTS are
now evolving into C# classes and SOAP interfaces. Microsoft has
effectively skipped (or missed, depending on how you look at it, I
guess) the CORBA architecture altogether (save their proprietary DCE RPC
interface).
Honestly though, rewriting old code isn't always financially feasible or
even possible (the business knowledge to do so may already be lost).
This is why old code, particularly stuff in larger older companies, will
never die. It will live on with new interfaces. Always.
Emulation is our saviour. IBM 390 mainframes run under emulation now on
high-end PowerPC hardware just as easily as they do under x86 platforms
and under OpenSource emulation with Hercules. Old platforms don't die,
they live on as emulated environments hosted on machines that are
multiple orders of maginitude faster than the origional hardware they
were designed to run on. Architecture, inevitably, doesn't matter.
Emulation is the future of Von Neuman computing.
That's my take on things anyway.
- Ian C. Blenke <icblenke@nks.net> <ian@blenke.com>
http://ian.blenke.com
This archive was generated by hypermail 2.1.3 : Fri Aug 01 2014 - 20:17:04 EDT