Computer-science: Request for Comment: Removing/Replacing Software Construction

[riceeatingmachine]

Problem:
Both the Software Construction courses are terrible in quality and do not teach much. UBC has also decided to force students to pay to have access to the problem sets.

Duration:
Feb 29, 2020

Current State:
Awaiting feedback

Proposer:
riceeatingmachine

Details:
As I myself took the SC course and as many others have pointed out (https://github.com/ossu/computer-science/issues/422#issuecomment-385592611 for one), the quality of the SC is really bad.

The course is a part of the Software development micromasters from EdX, consisting of 6 courses in total.

The first two (How to Code - simple data and complex data) are very good and rigorous, although somewhat monotonous but they teach you very much. This is because the teacher for those courses was teaching these in some MOOC or another for many years before the micromasters was a thing.

It appears that UBC had some commitment to EdX to produce the other 4 courses but did not want to do it, so it produced very quick and superficial courses just to satisfy those commitments.

There are no TAs, the setups are outdated, and the final capstone project is all but abandoned, as you can see in the reviews here or by enrolling and reading the discussion forum:

https://www.classcentral.com/course/edx-software-development-capstone-project-8198

To add insult to injury, UBC forces to to pay to take these terrible and abandoned courses, which itself is against the principles of the OSSU.

Proposals:

Option 1: Removing the SC courses altogether

As they do not teach much in the courses, I do not think anything is really lost by removing them form the syllabus. In fact, removing them kind of improves the OSSU by making it less bloated and more streamlined.

There is no knowledge lost. The only thing I learnt form SC was that code can be split into various files and imported to the main file for development ease.

Here, we could add a link to the Java tutorials to introduce the student to OOP.

https://docs.oracle.com/javase/tutorial//java/index.html

Option 2: Using the old MIT courses

MIT used to have 6.005 available on EdX (now archived but accessable)

https://www.edx.org/course/software-construction-in-java

OCW version: https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-005-software-construction-spring-2016/

@Alaharon123 pointed this course out to me, although I have not taken it yet. The Java Tutor bits are no longer available.

Option 3: Using some sort of book to teach this portion

[Suggestions needed]

Other things:

1. The software development capsone project needs to be removed from the course regardless of the outcome of this discussion. This is because that course is completely abandoned and it's impossible to complete the capstone because the grader does not work anymore. Only one person has completed that project in it's history, and it costs $300 to access that broken course.

2. Perhaps the entire micromasters needs to be removed and we should bring in a different programming series into the OSSU from a more active university.

---

Few other commenters who reported having negative experiences with Software Construction:

@chrisdziewa at https://github.com/ossu/computer-science/issues/422#issuecomment-385592611
@andrewtcooper at https://github.com/ossu/computer-science/issues/478#issuecomment-389172005
@hanjiexi at https://github.com/ossu/computer-science/issues/504#issuecomment-427859760 and https://github.com/ossu/computer-science/issues/553#issuecomment-451061546

[Alaharon123]

I would probably recommend the OCW version over the edX version what with the problems with edX and the missing resources and all.

I also think https://web.cs.wpi.edu/~cs2102/b16/ should be considered and I hope someone can do that after the How to Code courses and report back on how well it works for self-learners.

[ghost]

I'd be willing to do the WPI course on Java and give you some feedback on it - it seems like this is the perfect fit after the HtdP curriculum, albeit the content looks a bit dry for self-learning.
It might take me one more month to finish the courses before though.

Regarding Point 2 from OP:

"...Perhaps the entire micromasters needs to be removed and we should bring in a different programming series into the OSSU form a more active university.""

I think the first two courses are really nice and it makes total sense to transition into some OOP
course afterwards but the big question is how someone should substitute the last two courses from the micro master where they teach agile, software construction and finish with a full-stack project.

[waciumawanjohi]

I've been looking at our curriculum and at the CS2013 curricular guide. It seems to me that our Intro to Programming, Intro to CS and Core Programming cover the Knowledge Areas Software Development Fundamentals and Programming Languages.

Software Development Fundamentals (SDF) is described, "students must be competent at reading and writing programs in multiple programming languages... able to design and analyze algorithms, select appropriate paradigms, and utilize modern development and testing tools. This knowledge area brings together those fundamental concepts and skills related to the software development process. As such, it provides a foundation for other software-oriented knowledge areas, most notably Programming Languages, Algorithms and Complexity, and Software Engineering... identifying those concepts and skills that should be mastered in the first year of a computer science program."

Programming Languages (PL) as, "understand the programming models underlying different languages and make informed design choices in languages supporting multiple complementary approaches."

Looking at the Software Construction classes, it seems that they are meant to bolster the SDF topics. But I don't see any topics in SDF that are unmet by the previous courses and covered by Software Construction.

For that reason, I am in favor of deleting the software construction courses outright, without replacing them.

---

In both this issue and in https://github.com/ossu/computer-science/issues/553 there is discussion of adding a course on Java. The goal of that seems to be better coverage for the PL object-oriented programming (OOP) topics. Currently, OSSU recommends a trio of courses focusing on programming languages. It seems that it would be appropriate to have a separate discussion about removing those courses and adding a course on OOP.

[TheColtron]

FWIW, here's some feedback on how the two Software Construction courses fit in for me (currently on roughly my 10th course in the curriculum),

I actually quite enjoyed these two courses, and I think I gained a lot from them. That being said, I think I agree that they can pretty safely be removed without replacement.

The main benefits I got out of these courses were:

• Working with a much larger codebase was incredibly refreshing, and being able to make sense of the Twitter mapper in the final project was easily the most motivating part of the curriculum so far.
• The use of JUnit and all of the accompanying debugging lessons were also very useful, and those skills have helped me directly in every course since.

The courses have some issues and I can definitely see where a lot of the criticism is coming from, but even though I personally enjoyed them, they don't feel like they belong in Core Programming. They were great as supplementary material, but nothing about them feels integral to the curriculum, unlike the Programming Languages series that follows.

[spamegg1]

I would agree with removing Software Construction courses without replacement. I took those courses and did not really learn much from them. In those 2 courses I wrote 0 algorithms and solved 0 problems. All "code" I wrote was boilerplate and ceremonial. It was 100% about "accounting and bookkeeping" with Java's internal bureaucratic nightmare of objects, classes, diagrams and such.

As for satisfying the PL requirement for OOP, "Programming Languages Part C" covers OOP with Ruby. There is coverage of classes, inheritance (both single and multiple) and it argues that Ruby does multiple inheritance better with Mixins (as opposed to MI in C++). There is a very detailed programming assignment that compares and contrasts OOP (Ruby) with Functional (ML), and it shows what "full commitment to OOP style" looks like by requiring to write code with Double Dispatch etc. and breaking down subcases in a function into separate subclasses that interact with each other instead.

I think the main issue seems to be Java, not OOP in general (which I think is perfectly covered in PLC). It seems that Java is this special thing; it has its own special, peculiar universe of concepts, words, ideas very different from the rest, and (IMO unfortunately) is very popular in the industry.

When I was going through the curriculum, the "Java courses" felt like they were separate from the rest of Computer Science and a thing onto themselves. With all the other courses I felt like I was learning about programming in general and they fit common themes, ideas and problems, parts of a wide tapestry; and then out of nowhere came some very strange alien concepts and ideas of Java that did not fit in with the rest of CS and felt very forced and artificial. I felt like I was taking a break/detour from the curriculum because someone was forcing me to.

I think that since OOP is covered in PLC, there can be an elective optional course LATER that's like "hey, here's a Java course if you are interested specifically in Java". Certainly Java is not the only OOP deal in town. Arguably Ruby and Scala do it much better.

[riceeatingmachine]

### Close of Comment Period

Findings:

1. Almost every student who has left feedback has found no reasonable value from the Software Construction courses.

2. No comments have been received regarding capstone project courses.

Response:

The comments above suggest entirely removing the software construction courses without replacement. This would be an improvement to the OSSU as it reduces bloat courses that take up student time and do not add value in terms of knowledge in return. Further, EdX is now asking students to pay to take these courses.

Conclusion:

OSSU will remove the Software Construction courses from the curriculum.

[aryzach]

I also took this class and found it mildly helpful. I think this might be useful in a separate SWE track. Working on large code bases is difficult, but also a difficult thing to teach in a class. I'd really like to hear some feedback about the WPI courses before taking them.

Also note that the PL class (3 parts, SML, Racket, Ruby) have a very different take on OO. The PL class is teaching language concepts (like closures), while the Software Construction course teaches you to use those tools to implement application features (design patterns, UML diagrams). Both are important, but also largely different. One is close up on the language, while the other is zoomed out to mimic software engineering.

Here's my write up from a separate post:

[lalitsom]

Hi,
As this course is removed.
could you suggest/Add any replacement course which could teach Object oriented programming in detail.

[waciumawanjohi]

This is the focus of Programming Languages Part C. You can find it here in the curriculum.

If you would like a more in depth course on an object oriented language, Extras/Courses recommends the University of Helsinki's Object Oriented Programming with Java.

[aryzach]

@waciumawanjohi speaking of this, could we change the requirements for 'Software Engineering: Introduction' to just have Programming Languages, Part C? I would do it myself, but I'm not really familiar with process or with pull requests in general

[waciumawanjohi]

I'm interested to hear your reasoning. Check out https://github.com/ossu/computer-science/blob/master/CONTRIBUTING.md#substantive-changes
If you have questions about the next steps after reading that, you can send me a direct message on gitter.

[kachmul2004]

@lalitsom I am a beginner here. If you would want to learn some Java, I can recommend this course/book http://math.hws.edu/javanotes/

I used this some 10 years or so ago and its been constantly updated. It was actually my first taste of programming while I was still in high school, but I stopped learning for various reasons.