Well, as somebody else said, it's like the difference between English and Chinese... Both can be used to write a story, both can get ideas across, but if you only speak English and somebody gives you a book in Chinese, you have no idea what to do with it and vice versa.
Don't even worry about the CISC-vs-RISC stuff,because, frankly it doesn't matter. Even if you're comparing 2 RISC or 2 CISC chips, it still doesn't work...
Think of it this way:
Both PowerPC and Intel x86-64 have instructions that do things like:
add
subtract
load data into a register from memory
multiply
branch
etc.
The difference is in HOW they do it, how MANY of them there are,etc. Intel might have an instruction that takes 2 numbers from registers and stores the result directly into memory and another that takes 2 numbers from registers and stores the result into another register. PowerPC might only have the later. PowerPC might have an instruction that can divide an integer and a float, Intel might not. Even if they BOTH have instructions that do the EXACT SAME THING, they might work TOTALLY differently.
What does it mean to "execute an instruction" on a CPU? In general, when the code tells the CPU to execute an instruction, there's a table (the microcode) that looks at the name of the instruction being executed, looks it up in the table, and that table has a pattern of 0's and 1's that turns on and off different pathways in the CPU to turn on and off and select different things in the chip to make that instruction do what it's supposed to do inside the chip. Since the 2 chip designs are totally different, then the same instruction does totally different things inside the CPU.
So, you can't just take Intel assembly-language code and run it on PPC or vice versa. The instructions aren't the same, and even if they were, they don't work the same way. The number of registers to put stuff in is different, etc.
Now, with high-level languages like Objective-C or even C (well, that's semi-High level) when you compile, converts the the high level code down into CPU-specific Assembly code which the CPU runs. So it's translating from a generic language down into the specifics that your hardware understands. This is even different from CPU family to CPU family within the same brand. For instance, if you want to tweak every bit of performance out of your code that you want to run only on a G5 PPC, you'll turn on flags to tell the compiler - optimize the code you make to take advantage of G5 chip architecture and features. Likewise, the code produced for a Core 2 Duo chip isn't quite the same that the code for a Core i7 chip is. Usually what you'll do though is make the compiler generate for a whole chip family, and then if it detects a specific chip it'll kick in special routines to take advantage of those options.
So, the idea here is that if you stick with higher level languages, you just write your code and let the compiler worry about the underlying architecture. In the case of the Mac, you can tell the system to build a "unified binary" where it'll basically compiler your code twice, once for PPC, once for Intel and then package the two together. When somebody with a PPC tries to run your program, it'll detect that it's on a PPC and run the PPC code in the package, if it's on Intel, it'll run the Intel version. While this works fine, it means that you're effectively carrying around 2x as much information for no reason (since you can't use both at the same time.) That's pretty wasteful. It's one of the reason Apple is dropping PPC support in 10.6.
In reality, unless you're writing assembly language code by hand, or doing CPU design, you really don't care. It's just a processor, and it does things. That's all there is to it. You write your code, let the compiler worry about the specifics...
If you really want to learn a lot about CPUs and how they work , pick up a copy (used or new) of: "Computer Architecture, Fourth Edition: A Quantitative Approach (The Morgan Kaufmann Series in Computer Architecture and Design) (Sep 27, 2006) by John L. Hennessy and David A. Patterson"
(Actually, even the old versions are fine.....) You can bypass a lot of the math and just focus on the concepts. This is the book we used in my Advanced CPU design class and it explained a lot to me.