Software Engineering 3F03 is a course shared by both third year software engineering students and third year mechatronics students. The class is relatively large coming in at about 100 or so people.
If you are a software engineering student who took SFWR ENG 3GA3 with Dr. Karakostas, then you can consider SFWR ENG 3F03 to be a
hands-on or
practical version of that course. While 3GA3 was concerned with the actual design of a computer processor (using generalized MIPS processors as the in-course example), 3F03 is concerned with writing assembly level programs using the x86 instruction set. The x86 instruction set is what actual desktop and laptop Intel and AMD machines use (MIPS is mostly for teaching and specific embedded applications) and is vastly more complex than the MIPS instruction set. Fortunately though, there is no concern for the actually design of the processor in this course and all that matters is the general principles learned in 3GA3, which apply to any processor.
Now if you're in mechatronics - don't be too scared. Although software engineers covered details a lot more precisely than mechatronics engineers, people in mechatronics got a decent enough look at the whole thing in MECH TRON 3TA4. People in software engineering and embedded systems took both courses, so I like to think they're the most prepared for this course
.
The course begins by teaching the basics of number representation in a computer. Of course, the computer stores everything in binary, but those binary numbers can be 'simplified' for human reading by changing from base 2 to base 8 (octal) and base 16 (hexidecimal). Basic base conversion (base 16 to base 2 . etc) should already be known by anyone taking this course. So if you're in the course and you don't know this - learn it now!
Following that, there is a brief introduction to the history of the x86 architecture. You learn the difference between protected vs. unprotected mode vs. real mode and the registers available in all 32-bit x86 processors. This is rather complicated information explained briefly, so don't worry if you don't understand. The only thing really important is knowing the registers for future use.
After that, you begin with the actual x86 assembly language in the NASM style. There are several 'dialects' of x86 assembly, AT&T's being most popular in the real world - but NASM is the easiest for teaching. There is a TON of information to be learned here, so I'm going to briefly cover everything. You start with basic instructions of the form "instruction register1, register2". This means 'perform instruction 1 on register1 and register2, and then store the results in register 1.
For example,
add ebx, ecx
This means, "ebx = ebx + ecx".
Gradually you move on to not only working with registers, but also working with RAM. Registers are just an extremely high-speed scratch space where the CPU gets work done, but the RAM is where the results typically end up in larger programs. Typically one stores the results of adding two registers, a register and a constant, or a register and a memory location into a register - and then moves it to memory.
After that, you learn about branching statements (what looks to you like IF statements and loop statements). Interestingly enough, you want to avoid branching statements because they create a lot of extra work for the CPU. I'm not going to go into detail about it here, but the CPU can end up wasting a lot of time processing things that don't matter when excessive branching statements are used.
Finally after learning basic assembly, you move on to subprograms. These are programs written in assembly intended to be called by C programs. You learn the C calling conventions (storing values on the stack. etc) and how to even call C programs from within assembly.
Finally it ends with arrays and floating point operations using the floating point registers. It also goes into optimization using loop-unrolling and fortran structures a little bit.
When I took this course, it was taught by Dr. Nedialkov. To be honest, I didn't listen to him at all throughout the entire course. I spent most of his classes just playing angry birds on my phone, so I can't really tell you whether or not he's a good professor. What I did was just learn from the book, which can be found for free
here. Ned's lessons come entirely from this book and he basically follows it word for word.
He deviated from the book at the end of the course and started teaching C++. It wasn't on the exam, so I didn't really listen. It seemed to be just basic object oriented stuff in C++. Nothing fancy.
The course breakdown when I took it was like this:
2 x midterms (15% each)
4 x assignments (6%, 6%, 8%, 10%)
1 x final exam (40%)
I found the course overall pretty easy. If you actually read the book and are good with programming, it shouldn't be too much trouble. I wouldn't recommend leaving the assignments to the very end, because strange little bugs can take hours to fix. If you honestly do the assignments, the midterms should be relatively straight-forward as well. The only thing about them is that you're a little time constrained; so don't waste a lot of time. For all midterms and the exam, you're allowed a printout of the x86 instruction set on the last few pages of the PDF text book.
The exam was very easy - almost a joke. It involved a lot of simple questions like "What is 0x0043 AND 0x1110?" and a couple straight forward assembly programs similar to past assignments or examples. Almost everyone was done in about an hour. I would recommend looking over any past midterms/exams you can get your hands on for practice. They're quite helpful in ensuring you can write out assembly code at high speed.
At the end of this course you might think to yourself, "But we have compilers that do a better job than people, why do I need to learn assembly?". Assembly isn't to be learned for practical reasons really as it's highly unlikely that you will ever be required to write raw assembly in the real world. The reason it's good to learn assembly is to understand how a computer works and how to make your programs more efficient for the processor at the higher level. It teaches you that things that may be simple in a higher level language like C are actually more complicated when finally executed.
I got a 12 in the end, and a lot of other people got high marks as well. Just read the book and understand it, and you should be fine.
