SWEN20003: Object Oriented Software Development

(copied from showtime)
Project 1 [8%]
Project 2 [22% in two parts, 6% & 16%]
Midsem [10%]
Final exam [60%]

I think @showtime gave a good summary of the content in the previous review, just wanted to add my comments of why I rate it 4/5 instead of 5/5.

The main problem is due to the structure of the subject, you don't have a chance to practice half of the content in your assignments. Basically you aren't really specified to use any techniques in your whole assignment that is from the second half of the semester.

Due to the fact that in second half of the semester, everyone is working on their assignments instead of lab work (at least in my class), that means no one really gets exposure to the more advanced subjects. I honestly didn't write a single interface or enum in an IDE for the whole semester, might be I'm a bad student but yeah just the way the subject is structured. In past experience, assignments were a bit more aligned with the content.

And this subject demands functioning code, not good code in an algorithmic sense. Matt said that we are aren't in an algorithms class, so just make it work. But the code does have to be good in that it's documented, but that is like previous classes.

Every lecture you have with Shanika (a small amount) you will kinda miss Matt, doesn't help that she teaches somewhat more of the drier content of OOSD. Eleanor designs the assignments (iirc) and she took 2 lectures, one on Git (not examinable) and Game programming as well, she wasn't bad.
Overall though, this subject is a decent flex into Java, IDEs, maybe even Git if you're keen! Projects were fun to do if you were on top of your stuff I had a lot of fun playing with Slick. The subject does have success in that it can teach you about the importance of design before tackling a complex program (the assignment), it's just that you never got to see much of the later content in action in your own hands.

Yes.

Matt de Bono (primary) , Shanika Karunasekera (minor), Eleanor McMurtry (more minor)

2 sample exams were given, no answers

4 Out of 5

Nothing required

2 lectures, 2 hour workshop and lab

2018 Sem 2

H1

Project 1 [8%]
Project 2 [22% in two parts, 6% & 16%]
Midsem [10%]
Final exam [60%]

This fantastic subject uses Java to introduce you to the world of object-oriented programming (OOP) and, yes, software development. The subject is roughly split into three areas: the Java language, OOP concepts, and software engineering. Besides the coordinator, it doesn't appear to have changed much since the last review in 2015, but to sum up:

TOPICS

• Java- this part is mostly learning the basic syntax, which is quite similar to C (which the subject assumes you've used before). A Grok module is set up to make practice fun and easy, but since you've seen all these concepts before (arrays, looping etc) you're expected to get through this part quickly and mostly in your own time.
• OOP- this part teaches you about the features and concepts of OOP, such as polymorphism and encapsulation, and how they factor into good code design. You'll inevitably end up making comparisons to Python and C, but you'll also be quickly forced to break out of your old ways of thinking. However, the new ideas are not too difficult and once you understand what's going on, using them becomes fairly intuitive.
• Software design- this part introduces you to UML modelling, as well as design patterns and development frameworks. Although there's not a whole lot of work associated with this, a decent chunk of the exam is dedicated to how well you know and can apply these.

ASSESSMENT

• The midsem and the exam are both very fast paced, but quite fair and have no surprises. They also closely follow the layout and difficulty of the samples, so doing those is highly recommended even though solutions aren't supplied.
• The projects are just the right mix of challenging and fun. This semester, we used the Slick game library to recreate the classic game of Frogger, with the bonus option of adding in whatever creative licence we liked. Project 1 involved implementing one level of the game, then lots of small complications (more enemy types, multiple levels etc.) were added for Project 2, with 2A being a diagram that proposes the structure for the entire game.

OTHER

• In my experience, all the teaching staff were great. In particular, main lecturer Matt is a lot of fun, but better than that, he is exceptionally clear when explaining everything from concepts to expectations.
• Compared to first year computing subjects, more time and effort is definitely required from OOSD. This subject doesn't just require functioning code, it demands good code, and for that you'll need to plan.

Overall, this subject is very interesting, well-taught and fun. Chances are, it will be your most enjoyable computing subject yet!
(Edit: I originally gave this a 4.5, then moved it up to a 5 when I had trouble thinking of faults. However, stevenhuyn articulated some good points so it's back down to a still excellent 4.5 for me.)

Yes, with screen capture

Matt de Bono, Shanika Karunasekera

Yes, and a sample exam

4.5 out of 5

None

2 x 1-hour lectures, 1 x 2 hour workshop

Semester 2 2018

H1

Overall, assessment in this subject is pretty fair.

The projects are a huge step up from first year stuff, and you're expected to have a well designed application, rather than an application that merely "does the job". This semester we were required to write a 2D top-down racing game where you race against 3 AI controlled opponents, with the help of the Swing 2D game library. I believe last semester's project was a 2D top-down RPG. I would have preferred to have done the RPG but alas, we can't have it all. The two projects build on each other. In project 1 you write the basic engine, and in project 2 you design and implement the full game using your engine from project 2. The projects are very challenging, but also extremely fun and rewarding.

The exam was very fair. With no surprises or so-called challenge questions. If you kept up during semester and did your best at cramming everything the night before, you should be fine.

A very good subject, with fair assessment and good content. If you like programming, you will like this subject. But, you need to work a lot harder than first year, and put more thought into your code design before actually implementing it.

When Civil Engineers design a bridge, they ensure that the chance of it collapsing is as close to zero as possible. But how many times have you had to force-close an application, or have had to restart your OS? If Civil Engineers can design bridges that don't collapse, why can't we design software that doesn't collapse? In a nutshell, this is the problem that "software engineering" tries to address, and this subject will be your first door into the wonderful world of software engineering. Strap in, and be prepared to shift into 2nd gear, because this subject is NOT like your first year COMP subjects. Computing and Software Systems majors are required to complete this subject.

Yes, with screen capture.

Shanika Karunasekera.

Just one "sample" exam, with no solutions. I didn't do it.

4.5/5

I used Absolute Java, Walter Savitch, 3rd edition and found it very useful.

The topics are loosely thrown into the following main topics:

• The Java language and all it's intricacies
• The concept of "object oriented programming" (OOP) and it's main features
• Introduction to software engineering: development frameworks and design patterns

The subject begins by teaching you the Java language with the assumption that you know C. Their syntax is quite similar, but Java is NOTHING like C (there's no pointers, so you can let out a sigh of relief). Java, in all its glory, is a very nice programming language. Java is fun. You will grow to love Java. The amount of included libraries is absolutely phenomenal, and that's only the standard ones. There are also tonnes of third party libraries out there on the internet. I won't say much about this part of the course, it's your basic "lets all hold hands and learn a programming language" that you would be very familiar with from first year.

Next, the subject moves into teaching you about the object oriented design paradigm and it's main features: encapsulation, inheritance, and polymorphism. You will learn about the differences between object oriented and procedural programming languages (such as C). You will also learn how the features of OOP promote good code design, and how to use them to write well-designed code. In this part of the course you really need to keep an open mind and really think hard about what they're teaching you, some things might (will) not be immediately obvious.

The final part of the course will introduce you to software engineering, where design is king. You are introduced to the concept of design patterns and development frameworks (the latter which you would have already used in the projects), as well as UML modelling. I stress that this is only an introduction, and there are many many more things that are yet to be covered, which you will learn in your final year subjects. This part of the course is pretty chill, and doesn't require much work. But you should think about how the design patterns they introduce could be used in practice, they will appear on the exam, and you don't want to be surprised.

2 x 1-hour lectures, 1 x 2-hour tutorial/lab

Semester 2, 2015

TBA