Quote:
|
Originally Posted by FunkFaker ....that makes it necessary for most software developers to rearrange their programs to suit? |
The heart of the matter is that the two processors speak a different "language" (the patterns of bits that tell the processors what to do.)
In the best of all possible worlds, software written by the programmer ("source code") is done in a language that is not specific to any processor ("platform-independent"), and one that is at least somewhat human-friendly (with words like "if" and symbols like "+".)
The software is than translated into processor language ("object code") by another program (a "compiler.") If the source code is truly platform-independent, all that should be necessary is to recompile the source code with a compiler that generates object code for the new processor. The Mac development environment ("XCode")generates object code for both PPC and Intel and wraps them both up in a single package ("Universal Binary.")
Usually it's not as easy as this. There are a number of impediments, some blatant and some more subtle:
1) The software was developed in an older development environment (not XCode) and first has to be made to compile under XCode.
2) The software contains code written to take advantage of very specific features/instructions of the processor. This code needs to be rewritten for the new processor (or in a more abstract, processor-independent way.) This is often the case in DSP software (plugins and the like) as performance improvements are possible.
3) The software contains code that accidentally only works on the old processor (usually due to things like the order that individual bytes are stored in memory.) These can be hard to find, and necessitate going through the code carefully.
This process can take anywhere from minutes to months, depending on how careful the software engineers were when they originally wrote the code.
There is an additional dimension to this, which is the O/S. Most applications have software that implicitly "knows" what o/s they're running under, and getting something to run under multiple o/s's can be quite an undertaking unless careful design was done up front. This is one reason why you're not going to be seeing Windows .exe apps running under MacOS, even though both are Intel object code.