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
|
By:
Mark Murphy
(C) 1998 - All Rights Reserved
Not for reprint without
permission
On the Rhapsody Discussion List, a subscriber asked the following question with respect to YellowBox on MacOS:
Could YellowBox mean the near end of the MacOS development, in order to concentrate on just Rhapsody (one OS) inside Apple?
The short answer is no.
Many people are not developers, so let me explain a few things which may help readers better understand the situation.
At the core of the MacOS is it's rich set of APIs (Application Programming Interface).... we use to just call them the Toolbox and OSUtils.
Previous to the Mac --
Programmers use to have to *always* roll their own *everything* if they wanted to develop a product. About the only thing the Operating System had was some calls to read and write files (Apple DOS 3.2, ProDos, DOS).
If a developer wanted to use any kind of libraries, you might find some for sale, but you were pretty much on your own. There were a few programs on the Apple ][ and DOS that used a GUI (Graphics User Interface), but these were few and far between.
If a developer wanted to do a GUI, they had to write *everything* themselves. All game developers had to write their own stuff as well.
What do I mean by own stuff?
Well, there was no such thing as a standard button... there was no such thing as QuickDraw... there was no such thing as a Window. If a developer wanted to put graphics on the screen, they had to write to the RAM location which represented the pixel. If they wanted to draw a line, they had to write their own line drawing routines.
In other words, programmers had to spend most of their time writing their own libraries... then the program.
This is why programs were not as full featured before 1984 as they are today.
Then along came the Mac.
The Mac came with a whole group of pre-done tools... all ready for the developer to take advantage of. It had a full set of graphics tools to draw lines, polygons, circles, and *regions*. It had libraries to handle all kinds of buttons, text fields, dialogs, windows, etc.... not to mention a ton of OSUtils to handle memory management, file read and writes... and resources!
Now programmers didn't have to roll their own any longer!
But what exactly *is* the MacOS? Is it the set of tools provided to the programmers... or is it the Finder, System, and the user utils that make the machine function as we know it today?
It's both.
The Finder, System, Controls, QucikTime, Networking, and other OS tools we use every day are built upon the MacOS set of tools known as the API (or the Toolbox... or SDKs, etc).
So to the user, there's a nice comprehensive operating system which allows him or her to do their work with ease. The MacOS design philosophy and use of the built-in APIs allow developers to provide a consistent look and feel to their applications.
So where does YellowBox for MacOS fit into all of this?
Is YellowBox a new OS? Does it mean the MacOS will go away?
Of course not.
YellowBox is *not* the underlying OS... it is simply just another API! YellowBox is a set of APIs which will allow programmers to do even *more* than they could do with just the current MacOS APIs.
YellowBox is fully object oriented. For years, Apple has been trying to transition from the old MacOS API model (now near 15 years old since inception) to a new object model. With YellowBox ported to the MacOS, Apple gains this new object model without throwing away the old APIs in the process.
If YellowBox is just another API, then what makes it so great compared to the current MacOS API?
This answer can get quite technical, but I'd like to just keep it simple so non-developers will have a better understanding.
Just as the MacOS APIs allowed developers to do new and wonderful things they could not do before because they'd always have to roll their own, the YellowBox APIs allow developers to move to that next plateau.
YellowBox has built-in objects which allow a great amount of code reuse.
YellowBox objects are also ready for networking. As a developer, I can easily write a program which uses objects not only on my machine, but on other machines... without having to roll my own networking code! So a developer can easily write an application ready for the power of the internet in ways which make current browser technology look like a game.
YellowBox objects have powerful advanced programming features built in which are not found in the current MacOS APIs (or Windows APIs). The YellowBox objects allow a developer to only write a few lines of code which would take sometimes *hundreds* of lines in the MacOS APIs... so a developer's work is greatly reduced... allowing him to get back to the business of thinking up the next great application or utility.
YellowBox objects already have power built right in. The objects to handle text input are damn near close to a full word processor! The MacAPI's aging TextEdit manager can only handle 32k worth of text and can be very difficult to use. Most developers have to roll their own on top of the TextEdit Mac API to do anything more powerful. The YellowBox objects to which handle graphics work with several different graphic formats. No need for developers to roll their own graphic decoders.
Best of all, the YellowBox API is available on Apple's new Operating System named Rhapsody (which runs on both PowerPC and Intel processors), on Windows 95/NT, and will be available on MacOS!
This means developers can write their code once and simply recompile for their target platform... much like current MacOS developers do now for 68k and PPC code. A single YellowBox application can have everything needed to run on all supported platforms.
Not only that, but YellowBox keeps the native look and feel of the underlying OS. For MacOS and Rhapsody, this doesn't mean much since the two OSs are converging on look and feel. However, this means when a developer writes a YellowBox application and wants to provide it to the Windows market, it will have a Windows look and feel. This is very important for customer acceptance which in turn is important to developers accepting YellowBox as a development API.
So, will the YellowBox mean the end of the MacOS in the near future?
No it will not. Apple seems to understand very well that the MacOS has a market with customers who want that product. YellowBox will enhance the MacOS just as it enhances Windows 95/NT. It will allow developers to provide advanced, more powerful applications without having to force users into a new OS.
The MacOS will live as long as there are customers willing and interested in purchasing it in significant numbers.
However, I do anticipate that over time as developers use the YellowBox APIs and as the old MacAPI applications become fewer and fewer, nature will take its course. The MacOS will eventually go away.... but only in it's time and only when users have moved onto Rhapsody.
Never fear however. This will take some time and I suspect there will be die hard MacOS users running BlueBox (MacOS compatibility under Rhapsody) well into the year 2010, just as there are people running Apple ][ emulation on their Macs currently.
Related Articles:
- Understanding Languages -- more detailed explaination of API's and Libraries.
- What is Rhapsody?
|
