Originally Posted by rotuts
Hello
somewhere I read something about apple saying they changed something in Tiger that they would no lonoger change in future updates/incarnations. this basic process was the reason there were so many incompatibilities with Tiger
so my question is: what was changed in 10.4 that causes most of the inconpatabilities? resonably technical explanation, but I haven't programed in a long long time .
and did apple claim that this won't happen again?
I hope those who know what Im aiming at have some ideas,
rotuts
Well, there is absolutely no way that Apple can guarantee that there won't be incompatibilities with newer releases of the operating system and updates, etc. There are many different things that can cause incompatibilities.
In the early days of OS X, the programming interface (API) was largely incomplete. With later releases, things changed quite a bit and this caused some applications to be incompatible with newer releases. With later versions (especially with Jaguar, Panther, and now Tiger), the public API has largely stabilized to the point where most well-behaved applications will not have problems with a jump as big as Panther-->Tiger, and indeed most programs don't.
Then there are bugs in the code. Some of the networking type applications are incompatible because of a bug in the kernel of Tiger. Apple has to fix this before those applications can work. In a release such as an operating system, there is no way you can catch all bugs right from the start. Testing can minimize the number, but things still slip through.
Then you have things like security updates and the like. Sometimes to truly fix a security hole you have to change the way something fundamentally works. If an application depends on the old functionality, it will break once the fix is applied. This is not Apple's fault (unless you take the stand that the hole shouldn't have been there in the first place), nor is it the developer's fault. The solution is for the developer to fix their application to take the new functionality into account.
Certain low level things, like drivers almost ALWAYS need to be rewritten for a major new operating system version because so much low-level stuff changes a lot more than the higher-level things (like public APIs). Perhaps Apple is making less changes to this now so there won't be as many problems, but there will always be some incompatibilities.
Then you have programmers who do undocumented, unsupported things. Apple has a separate set of programming interfaces that are private (for their use only). These interfaces are not documented, and to use them you have to study them to figure out how they work. There is nothing to technically stop programmers from using them, but if something is undocumented and unsupported by Apple, then it's not their fault if those private interfaces get changed (and they frequently do). Apple even states that if people use undocumented interfaces they can't guarantee that functionality will be there even in a minor update to the system. You will see a LOT of incompatibilities arising from this.
Then you have totally new sections of the system that weren't there in earlier releases (such as Spotlight and the Spoken User Interface, for example), that are so integrated into the operating system that they may cause unforseen problems and interactions with many programs (As in Spotlight causing problems with Entourage by trying to index one of its data files). Again, testing will uncover some of these, but not all of them, and some will slip through no matter what.
You also have incompatibilities caused by Apple dropping support for older methods of doing things. (Like not being able to connect via AppleTalk to Mac OS 7 and 8 servers). In the case of AppleTalk, that protocol is 15 years old or more, and sometimes changes in the lower levels of the operating system make fixing compatibility with those things more trouble than they're worth. (To illustrate, let's say that there are only 15 people that use that method of networking left. If it takes 6 months of around the clock work to fix that functionality, and 6 months of work to fix something that 1,000,000 people rely on, they'll choose the thing that more people use. This kind of prioritization happens all the time. Sure, you'll piss off the other 15 people, but that's the way it works sometimes). You either have to adapt or stay with the earlier release.
In the coming months, Apple will be fixing bugs, which will solve some incompatibilities and create others (which is also inevitable in something as complex as an OS). Software companies will be releasing their own fixes as well. The things which sometimes take the most time are incompatibilities caused by reliance on private, undocumented interfaces, as they either have to figure out how to accomplish what they want using the public interfaces or figure out how the private ones changed.
I hope this (long) explanation helps you understand why incompatibilities are a fact of life, and no matter how much Apple tries to minimize them, there will ALWAYS be something to cause problems (whether forseen or unforseen). Apple (for the most part) does NOT set out to deliberately break something.
I'm sure some of the other programmer types can explain this better, but I think I covered most of the basics in simple language.
Top
