Software engineering 2AA4 is an introductory course to software component design, which in essence is the fundamental basis for object oriented programming.
This course is in a lot of ways a complement or a continuation of software engineering 2S03, which taught the functional and imperative programming paradigms.
The course is roughly divided into 3 parts:
1) The concept of information hiding, modularization and interfaces (OO-design fundamentals).
2) MIS (Module Interface Specification) and MID (Module Internal Design?) documents, pre/post-conditions + mathematical/formal specification
3) Verification/Testing
Information hiding and modularization with interfaces is the concept of making classes. A class is an abstract object with functions that can be used by other classes or programs. For a real world example, take a calculator. A calculator offers many functions on its interface with inputs (addition, subtraction. etc). You can use the calculator without having any idea how the internals actually work. The way the addition is done is the hidden information, and the functions you're accessing are part of the interface. If someone were to redesign all the internals to work more efficiently, the interface would still be the same meaning you would not have to learn anything new or change the way you use the calculator to use the new design. The whole point of modularization is hiding how things work and only telling the user what the things they can do are.
Defining these modules is done through the MIS and MID. To get an idea of what an MIS is, look at the
java library for random classes. It's basically a description of how the interface of a module looks for people who are using the module in a program they're making. It describes what the module does, and what each of the functions within it do. The MID is a description of the internals of the module and how it's actually implemented. There can be several implementations of a module (which means several MIDs), but there can only be one MIS. The point of this is that you can swap out implementations of a module in a big program without having to also change other things within the program. It's a rather intuitive concept.
The pre-post condition and mathematical specification stuff is overlap with software engineering 2FA3, and is basically a formal mathematical way of specifying what a method does on the interface to the user as an alternative to natural language. The purpose of mathematical/formal specification is that it can literally be proven whether or not your specification is complete. It will make a lot more sense during 2FA3...
Verification/Testing is pretty much just whitebox/blackbox testing. Blackbox testing is testing the interface (making sure inputs produce the right outputs) and whitebox testing is testing so that each line of the actual program is hit at least once. Again, this will make more sense when you get there.
When I took this course, it was taught by Dr. Wassyng. He's a pretty good prof and likes to get a lot of class discussion going. Things he really likes to focus on are David Parnas (this guy that taught at McMaster a million years ago that 'allegedly' invented the idea of information hiding) and Tabular Expressions (one of the main research topics at McMaster for formally defining software specifications).
The breakdown was as follows:
4 Assignments 20% (5% each)
Midterm 30%
Final Exam (50%) [ You must get >50% on the final to pass the course ]
Overall I found this course pretty straight forward. Pretty much everything that's taught is intuitive. The midterm and final were both open book and involved problems such as writing MIDs/MISs, filling out tabular expressions and writing formal specifications.
As long as you pay attention in class and do the assignments, there is no reason you should get less than a 10 in this course.
