As we learned earlier, programs are broken into assembly instructions, which are executed one-at-a-time. The question which naturally arises is what constitutes an instruction, and how many instructions we actually need.
There are two major categories of instruction sets:
The Reduced Instruction Set Computer (RISC) has a very small set of very basic instructions. These instructions usually include the basic logic operations (ADD, SHIFT, MULT, etc.), LOAD, and STORE (write).
These computers are comparatively easy to build, because they can do a lot with only a few wires and components. Because the operations are so small, they take very little time to complete. This means short clock cycles which fit neatly into the five-clock cycle.
The downside to this architecture is that you have to do a lot of programming. Everything you want to do has to be broken down to fit into these basic operations.
For a (relatively) easy example of the RISC design, check out the MIPS R200.
The Complex Instruction Set Computer (CISC) can have over a hundred different instructions, covering everything from the RISC set and then some. CISC is known to be able to perform very long instructions which perform multiple simple tasks simultaneously.
When you have that many instructions, you necessarily need more wires. You also need to provide more bits for the opcode (the binary which represents the instruction you wish to execute), which cuts down on the amount of bits you can use to reference memory or register locations.
CISC instructions can take any number of clock cycles to execute. As such, the design required to make the computer fast is extremely complex. This is why we usually introduce people to RISC assembly programming instead of CISC.
On the upside, however, if you have to read or write the assembly, you have fewer lines of code to look at in CISC.
The x86 and x86-64 architectures (one of which your computer uses) are CISC architectures. If you want to see how large the instruction set is, check out this table.