Advocacy
Dojo (HowTo)
Reference
Markets
Museum
News
Other
Myths
Press
General
Hack
Hardware
Interface
Software
Standards
People
Forensics
Web
CodeNames
Easter Eggs
History
Innovation
Sightings
Opinion
Martial Arts
ITIL
Thought
|
OLE is considered one of Microsofts great innovations, and a great gift to the computer community -- except there was nothing about OLE that was new.
The Clipboard - (the early 80's)
Apple created a clipboard in the late 70's that allowed users to copy data into and out of, and it was data type independant (it could handle any data). The concept of Cut, Copy and Paste existed long before Apple used it in the Mac (and Lisa), but those concepts had not been applied to the OS on a microcomputer before. Some programs supported Cut, Copy and Paste (or more commonly -- delete, copy, move and insert), but they did not work across multiple Applications from multiple vendors. By Apple creating the generic clipboard (with standard data types) and offering it as part of the Operating System, Apple not only enabled cross-Application Cut & Paste, it became a requirement for an Application to be "Mac-Like".
Apples OS support, standard data types, and examples worked great -- virtually every App could (and did) use the Macs Cut & Paste functions. Since many data types were standard, and the clipboard could contain more than one representation of the same data (at the same time), it was easy to guarantee that Cut & Paste worked across almost Every program.
When MS added Cut & Paste to Windows, they did not create as versatile a version as the Mac, and they did not define all those "standardized" data-types. Why should MS? Their intent is not to make the most versatile platform -- it is to earn MS more revenue. Microsoft dodged their responsibility with standards and only made sure that their applications worked with each other. In fact, MS goes out of its way to change their data types constantly so that others wont work with them (and so that their Apps work best together).
MS has this habit of making their stuff compatible with other Applications to gain market acceptance -- but then after they gain market success, they make sure that their Apps use proprietary data that no one else can work with. MS then loses their motivation to work with the other formats as soon as they are the biggest - then locking people in to MS's programs. This guarantees that MS can say "You need to use a Microsoft App. to work with MS data" and "Other programs don't work with our stuff very well". Microsoft also changes their data formats constantly (each version) so that competitors trying to work with their applications data have to keep changing their compatibility code -- and so the code is guaranteed not to work for a while (between revisions). This prevents users from choosing the best application for a job, and instead forces users to stick with MS Applications -- because if users try use a better App, then MS will guarantee that App will break in every subsequent version. While this is great for MS, this is lousy for users. Microsoft makes sure there are no Applications guaranteed to work with "standard" (see Microsoft) data types, except Microsoft. Even users of Microsoft apps constantly have to deal different file formats, one for every different version of every application -- causing support nightmares, user confusion, forward incompatibilities. But heck, Microsoft gets rich by doing it. Screw Users!
The result of not having those common data-types on Windows, and having them on the Mac, was that windows cut & paste didn't work well across multiple Applications -- while it worked great on the Mac. So Windows users HAD cut & paste -- but it really only worked inside the same Application. Microsoft was able to convince people that their cut & paste was as good as Macs, and the PC users were none the wiser. They didn't see what the big deal with Cut & Paste was, because they were using a cheap immitation. Mac users had things like a scrapbook, and could not only cut and paste inside one App, but also use that data in any other app as well.
This may have started the Mac vs. PC war. With Mac users stating their computer was better -- and the PC users thinking their computer was as good (based on ignorance). Sadly things have only gotten worse over time, and the biggest casualty has been the truth. Mac users are considered arrogant and obnoxious for understanding the truth.
Publish and Subscribe - (the late 80's)
Apple was still trying to make the computer better and easier to use. Apple created a new concept called publish and subscribe. Some Application developers had made similar functionality from within their Apps (like Ragtime on the Mac), but they had not made a universal system that would work across multiple Apps. The idea was that you could take a part of your document and "Publish" it. This made a piece of that document (or whole document) available for other documents -- then from these other documents you could "Subscribe" to that clipping, and get a live link. Whenever the original document changed, the document that had subscribed to that document would automatically be updated as well. It was a live clipboard, or a way to link and embed other documents.
Microsoft had been following Apple for years (and was privy to Apples development plans because they were a key Mac developer) and this idea was really powerful. So they copied it (big surprise). They called it either DDE or early OLE -- both are a forerunner of the OLE of today.
When Apple created publish and subscribe, they solved problems like sharing data across the Network. Apple made clippings files separate from the original file. So when I published a clipping, I could put it on the Network (in a public directory) and it was available to everyone. When other people linked to those clippings, my original document (or computer) did not have to be available to them (or even turned on). Remote users could not alter or harm my original document, and didn't need access to my machine. Furthermore, I could alter my original and NOT update the clipping if I wanted (which would not effect all their data). Of course I could update it -- and all their data would be revised live (if they were connected) or next time they opened their file that subscribed to that clipping. It was a very elegant system that solved many problems. Having a separate clipping file also allowed the publisher to subscribe to his own clippings, and allow others to alter his data -- or the data would be a one-way document (user could not alter it).
Microsoft has always had the philosophy of "Get something out fast! Fix it later! Charge for the upgrade!". That Applied to DDE and OLE as well. They did not try to solve the network issues in the first versions -- nor any of the problems known as "store and forward". (Having a separate file that is stored elsewhere and forwarded when needed). They are only marginally solved it today. Microsoft system was much simpler in design and functions -- it was also more limited. It used a system where the subscriber (linker) just pointed to the original file. If that file was across the network, and that file became unavailable, that was just too bad -- your document would have a blank spot. There were other issues with the users altering your data, or in many of the early versions one of the people using your data crashing and destroying your original file. The system also changed more than a few times, with limited backwards compatibility, and MS charging for every upgrade.
The irony is that MS's versions of DDE (and OLE) were more of a success that Apples' Publish and Subscribe. The reason was because Mac users were already trained on the clipboard -- and it worked well. They knew how to move data back and forth, and it worked well. Live linking was just a little bit of a convenience that only power-users cared about. But in the MS world, they didn't have a clipboard that worked well across multiple Applications -- but DDE and OLE did better. Early DDE/OLE versions also used lots of proprietary (Microsoft) formats, but these formats were less undocumented and volatile as version in the past, and so were more supported. Microsoft Office was also coming into its own, and it used these functions (and forced other to do the same). Also this feature add happened for Windows around Windows 3 and 3.1 -- right when Windows started actually getting some users. So it was easy to get adoption on this technology because the users were not pre-trained on how to already do that function a different way (less bias). So, surprisingly, Microsofts failure in the first part, led to more success when they made a less miserable failure in the second part.
OpenDoc and OLE (ActiveX) - (the 90's)
Apple was still not sitting on its laurels. In fact while creating Publish and Subscribe Apple went way way further in concept. They decided that every Apps data should be able to embed every other Applications Data. In fact, a concept was created that users don't care about the applications as much as they care about working with the data. If you made some changes to the OS, you could center everything around a document. Users would just work with different parts of a document (each with different data-types), and have to worry about the applications that were altering this data much less. These concepts are called "Document Centric" behaviors -- and led Apple to start OpenDoc and for many of these concepts to be in Taligent (an offshoot R&D/OS project). Of course the OpenDoc project was just a code name -- and Apple of the late 80's and early 90's was using colors to represent different projects (Blue was System7, Pink was Taligent, and Amber became OpenDoc).
Amber (OpenDoc) was a brilliant idea -- but Apple was doing their usual, trying to solve the engineering problems before they shipped it to users. MS was under no such restrictions, and had plenty of inside information on what Amber was. They decided to do for a less ambitious approach. Instead of doing it right, and allowing a document to be a generic container that any application could work with and view -- MS decided on an ethnocentric view of the world (and much less ambitious engineering project). They would just take their DDE (see Apple's Publish and Subscribe made cheap) and expand it a little. Instead of just embedding that data or linking to it, they would allow you to edit that data in place. It was a way to make multiple Microsoft Applications behave more like ClarisWorks (or other works packages that had existed for many years).
Now Apples ideas with OpenDoc were to make ubiquitous data types that everyone could work with -- and break Applications into smaller more specialized parts. This "factoring" (breaking into parts), allowed less work for programmers, and allowed more specialization (versatility) for users and much less training time, smaller footprints. Microsoft instead used OLE as the opposite. A way to integrate their big applications together, to make everyone conform to their custom data-types, and to break everyone elses Applications -- which made people use MS Applications. Face it, if you want to use ONE MS application, then you are forced to use them all, because Microsoft apps don't "play well" with others.
Since OpenDoc required people to open their minds and think, and MS's OLE required less change and was more backward thinking, and MS is better at marketing (see lying) and bigger -- they got people to buy into their utopia (OLE). Even though it can do 1/100th of what OpenDoc could do, and locks people in, and has been upgraded dozens of times (with each version increasing MS's revenue stream and crushing more of the competition) -- people still buy into MS's visions of utopia. Being an outside observer to MS's practices is like watching the cattle farmer leading the cow to the slaughter house.
What is ActiveX? It is basically OLE with some OpenDoc conepts mixed in (poorly). Microsoft caved in, and started allowing smaller OLE components, and some other "component" concepts. People think this is some innovation or something -- but it is just MS relabeling OLE-Lite and trying to sell it as a "new" product.
Conclusion
MS has made themselves on the business model of saving on expensive R&D by just copying Apple's lead. Except that MS copies poorly, and just hacks things together -- then charges people to fix their errors at a later date. The amazing thing is that MS has successfully convinced people that those upgrades they charge for are good -- and not the product of lousy engineering in the first place. Microsoft users often think they are getting something "New", instead of Microsoft fixing something they did wrong in the first place. If GM sold a car that had power-windows that didn't work (or would decapitate its users), GM could not convince the buying public that the later version (which worked without severing needed limbs) was an "upgrade" -- yet MS does this all the time. Saturn (the Car company) has not come along and tried to convince people that they invented the car -- yet MS does this as well. It is an amazing testimonial to American stupidity (and gullibility) that MS is seen as an innovator. OLE, ActiveX, and Windows in general are a perfect example of this fact. They are cheap, hacked up, poor-copies of Apples concepts. While Microsoft tries to play "poor" abused company (when people slam them), the truth is that MS gets slammed because of their practices. The more experience people have in the computer industry, the more they usually dislike MS (and its practices).
I use the term "Mac-Bigot" to describe myself, because some people have called me that. Those people want to discount many of my points -- and would rather challenge my motivation than their own knowledge and actions. So I wear their label as a badge of honor... and I welcome all of them to check the facts, and correct me where they can. I get very few corrections from them and instead I enlighten a few. Mostly I get experienced computer users who correct a date or a name here or there, and lots of spelling and grammar corrections.
|
