Hehehe, yeah, how down and dirty do you want to get?
Here's a brief overview of MIPS-RISC architecture (simply because it's much easier to describe than x86) from a high-level view:
When you write code in C++ or any high-level language, it gets translated into assembly. These simple instructions are those directly recognized by a CPU, and called the instruction set. For MIPS-RISC, there are (off the top of my head) the following formats of instructions:
R-type: ALU operations (add, subtract, bit-wise logical) and load/store to/from memory
I-type: Similar to R-type but using an immediate value
Branch: conditionally jump to an instruction address
Jump: unconditionally jump to an instruction address
If you have any programming experience, you would know branch and jump operations from conditional statements. High-level statements such as if, while, for, etc. are translated into branch instructions.
Also, whereas high-level languages often use variables located in main memory, MIPS-RISC uses registers for most of its operations. Registers are internal flip-flops that can store data, and have the advantage over memory that they can be accessed in the same clock cycle they are needed. For example, the add operation:
add $2, $5, $7
means add registers $5 and $7 and store the result in register $2. These registers are grouped in what is called the register file.
This sequence of assembly instructions are translated into binary by the assembler and stored in the instruction memory. Each line in assembly gets translated to a single instruction. Now we get into the internals of the CPU.
The following explanation is for an R-type or I-type instruction of a multicycle processor, which takes multiple clock cycles to complete an instruction. In between each physical part of the CPU is a latch that stores the results and control signals from the previous cycle.
The CPU has a register called the PC (Program Counter) which contains the address of the instruction to be executed. This address is fed into the instruction memory, which outputs the current instruction. Also, the PC gets incremented by 4, so that the next instruction will be called when needed. This cycle is called instruction fetch.
The next cycle is called instruction decode/register fetch. First, the instruction is sent to what is called the control unit. It reads the instruction and determines what type of instruction it is. Based on this, it turns on the proper control signals to the various multiplexors (they select between a number of inputs) and the ALU (arithmetic logic unit), so that the proper instruction is executed. Also during this cycle, the addresses of the of the registers to be accessed are sent to the register file.
The next cycle is execution. With the proper signals from the register file sent to the two inputs of the ALU, the ALU operation, such as add, subtract, and, or, shift, etc. is performed.
The following cycle is memory access, during which the contents of a register are either stored into the data memory, or a data/address is accessed from the data memory.
The following cycle is write back, when the results of an ALU operation or memory access are stored into the register file. Next cycle, the PC register will contain the address of the next instruction to be executed, and the process starts over.
In the case of a branch or jump instruction, the address is calculated from an immediate value (in the case of jump) or an offset (in the case of branch) and stored into the PC register. Thus, instead of sequentially executing the instructions in the instruction memory, a jump or branch instruction will jump to some other instruction other than the next one.
All of these structures described are implemented using logic gates, such as AND, OR, NOT, etc. Using a number of inputs that can have a high voltage (logic 1) or a low voltage (logic 0), the output is formed. These gates in turn can be implemented using transistors. How the actual structures of the CPU are designed from logic gates is much more complex...it would be best if you read this from a book.
As for credentials, I'm a CS (and physics) major, and I'm taking a microprocessor design class.