Computer-science: Re-organization roadmap for OSSU CS

[hanjiexi]

Continuing discussion from #421 and #418. Will add my thoughts later.

[chrisdziewa]

I just want to offer some feedback. I believe that the Software Construction courses from UBC are severely lacking in effectiveness. The first one varied between good and mediocre. The second is literally one of the worst learning experiences I've ever had. The instructors race through topics and somehow expect students to understand the advanced use cases of the patterns they barely explained. Then to make matters worse, they expect students to have an insane command over Java to complete the final project with requirements nowhere near reflecting that of the poor instruction given. As someone who has programmed for years in many different languages, I have to believe there is a better course offering available.

[hanjiexi]

I appreciate this feedback. I have mixed feelings about UBC Software
Construction.

I will start with the positive: the course exists for a good reason, which
is to expose students to the painful reality of trying to be productive in
an unfamiliar codebase written in an unfamiliar language that favors a
convoluted coding style. Feeling a little overwhelmed is part of that
experience.

What I don't like is that "making students feel overwhelmed" (on purpose)
is not really relevant to a computer science education. It's more like job
training, which should be done by companies, not by us.

What would be relevant is an in depth analysis of (1) the semantics of
object oriented programming; (2) the design process for large-scale
software, where decisions are made about the types needed by the system.

(1) is needed because traditional object-oriented programming is
complicated to describe mathematically, which in practice leads to lots of
indirection and makes it difficult to reason about. But, it is very common
and useful in some scenarios, so it needs to be understood.

(2) is needed because students of CS, regardless of whether they will go on
to be industrial programmers, should develop a robust understanding of how
to scale the systematic design process (learned in the "How to Code"
series) beyond a single module.

The Programming Languages course (mostly Part C, if I remember correctly)
goes into some greater depth on the design process, but still only on the
level of a single module (i.e. the types of functions: parametric
polymorphism vs. subtyping polymorphism). We need the same thing applied to
a system of cooperating modules, discussed explicitly and systematically.

All of this is to say that I want to replace Software Construction, and
there are many options for doing so superficially. At least one of the
alternatives I remember trying out was just as bad (I think it was the UC
San Diego Java course). But if we're just doing a superficial replacement,
it's not clear what the benefit will be.

I have so far not found what I'm looking for. That's why I want us to
design our own courses using publicly available materials (e.g. academic
papers) as sources. But this is a supermassive undertaking...

On Mon, Apr 30, 2018, 11:46 PM Chris Dziewa [e-mail]
wrote:

I just want to offer some feedback. I believe that the Software
Construction courses from UBC are severely lacking in effectiveness. The
first one varied between good and mediocre. The second is literally one of
the worst learning experiences I've ever had. The instructors race through
topics and somehow expect students to understand the advanced use cases of
the patterns they barely explained. Then to make matters worse, they expect
students to have an insane command over Java to complete the final project
with requirements nowhere near reflecting that of the poor instruction
given. As someone who has programmed for years in many different languages,
I have to believe there is a better course offering available.

—
You are receiving this because you authored the thread.
Reply to this email directly, view it on GitHub
https://github.com/ossu/computer-science/issues/422#issuecomment-385592611,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AFbnYidY3gFv46N2uALyINF38MCqyjc2ks5tt9qqgaJpZM4PSEb8
.

[chrisdziewa]

Thank you for your response! I really wanted to like the courses because I thought the approach was unique and because the subject matter was interesting and important. It seems that the course suffers from poor execution. Perhaps they were a bit overambitious to try to cover so much in such a short time frame.

Having control over course content creation would be awesome. It reminds me of what free code camp has achieved. But yes, definitely a massive undertaking requiring massive support.

Hope to see this project gain more traction because it is awesome so far.

[andrewtcooper]

FYI this course now costs $9 to access all its content without the certificate. I know that's not much but now it seems to go against the OSSU philosophy even more. Evidently Edx is now going to be doing this with an assortment of courses going forward as discussed in this blog post https://blog.edx.org/furthering-the-edx-mission/?track=blog so it's not clear how big of an effect this might have on the curriculum overall.

[hanjiexi]

@andrewtcooper I'm enrolled in Software Constructio but I didn't get an email about that, and I can't find any notice within the course about a price increase to $9. Where are you getting that information?

[andrewtcooper]

@hanjiexi I should have clarified, the Data Abstraction course is still free (for now) but the Object Oriented Design course is now showing as costing $9 to audit. There are other courses in the OSSU curriculum that are also now showing as costing $9 to audit, but I can't remember which ones off the top of my head. See screenshot: https://imgur.com/HMKVaos

[hanjiexi]

I've been holding off on sharing my long-term ideas because I felt they're too incomplete and too speculative, but now I think I need to just share them and start gathering feedback right away.

Some of this is only relevant to OSSU CS, and much of it is relevant to OSSU as a whole. I could have posted it here or the roadmap repo, but chose here for greater visibility.

Some day, I hope OSSU would exist as both an online and offline organization, offering a robust, cutting-edge, authoritative, unified, self-sustaining curriculum that is both simple to approach yet sufficiently challenging to improve the minds of its students.

• Online and offline: in addition to the online cohort model being used now, students could meet in physical study groups (using something like Meetup)
• Robust: the curriculum should be fairly complete in its coverage of critical topics
• Cutting-edge: the curriculum should adopt useful innovations both academically and pedagogically
• Authoritative: the curriculum doesn't need to be written directly by computer science PhDs, but it should reflect what they would teach and clearly show this connection
• Unified: the curriculum should all be centrally-hosted on one website, not spread across many different platforms that might suddenly decide to raise their prices
• Self-sustaining: a funding model and overall organization design is needed that enables cutting costs and raising enough revenue to sustain itself
• Simple but challenging: the curriculum should minimize the barriers to entry as much as possible; the challenge should come from the essential complexity of the concepts being ingrained, not the accidental complexity of learning a dozen different languages and dealing with various IT issues

I have some tentative ideas for how to implement these goals:

• Learners expect video content, but likely benefit the most from interactive content with tight feedback loops. If we created our own videos, they would need to be easy enough to update that they can be trivially modified without any re-recording. They also need to be cheap (ideally zero-cost) to host.
  
  
  
  • Proposed solution: a web app that dynamically generates interactive video-like content using a combination of text, interactive fields, vector animations for drawings, and text-to-speech narration. This would be a hybrid between interactive textbook and video lectures; from now on I will call them "interactive videos".
  
  
• Most programming languages are too limited to use for teaching every major concept with a clear and unobtrusive syntax, while also being useful enough to build real projects. The current solution is to teach a bunch of different programming languages, all with significant weaknesses and requiring a lot of extra time on the part of the student. Many of those languages can't easily run entirely online; I would want us to be able to use them within interactive videos as well as to build full applications for the web.
  
  
  
  • Proposed solution: use one programming language that conveniently and directly supports every concept we want to teach, compiles to both native and web, integrates reasonably well with the existing world of software, is permanently supported by a reliable organization, performs well enough to be usable for real-world projects, and has a clear syntax and straightforward semantics that builds upon what the student already knows. Nothing perfectly fits these requirements, but I do have some ideas for what comes close; I'll leave this discussion for another time.
  
  
• The current curriculum is too passive. You watch videos, you do some exercises, take some tests, but only occasionally get to build a project. How can you be sure that those exams really tested your knowledge?
  
  
  
  • Proposed solution (part 1): I suggest that the main curriculum, which is currently organized around major categories (Programming, Math, Systems, etc.) and further subdivided into courses, be instead organized around a series of modules, each of which culminates in a major project whose correct and elegant implementation requires understanding the topics. This would give OSSU something to grade each student on, students the practical experience needed, and future employers a nice portfolio to review.
  
  
  • Proposed solution (part 2): within each module of the curriculum, a student wouldn't immediately start building the project; they would work up to it through a series of exercises that take the form of puzzles. Such puzzles would ideally require both learning whatever new language constructs and/or concepts are needed to solve it, as well as providing some sort of visual feedback / interactivity. Example: students learning about finite state machines have to program an elevator. There would be a graphical representation of an elevator on screen, and it would behave according to the user's program. Students would make some change, and test whether the elevator is behaving correctly.
  
  
• Any successful product needs people who are responsible for things, even if much of the work that goes into the final product is from third-party contributors. Right now, we don't have much in the way of formal structure, and it is slowing us down.
  
  
  
  • Proposed solution: creation of a more formal virtual organization structure (even though we're still not legally incorporated) with individuals appointed to formally "own" certain responsibilities, coordinating and delegating the work as needed. We should continue to have people responsible for maintaining each individual repo, but we also need cross-repo roles. Three important such roles might be that of academic officer (responsible for ensuring the highest standards of all curricula and pedagogy), technology officer (responsible for coordinating all development needed), and the study/class coordination role (I don't know what to call this) already fulfilled by @amorriscode via his cohorts initiative.
  
  
  • I would suggest @waciumawanjohi for academic officer, as he has the relevant background in education. I'm not sure whom to suggest for technology officer, although I have gotten some messages from people interested in taking the lead on this.
  
  
• Following on the above, I feel that each student's success is also something that someone can and perhaps should be "responsible" for. But having one person responsible for every student's success doesn't scale.
  
  
  
  • Proposed solution: we complement the cohort system (which creates horizontal/peer accountability) with a mentor system (which creates vertical accountability). Students who are pursuing an OSSU certificate track who have progressed from module 1 to module 2 are now responsible for helping one student who is in module 1 and grading their projects. We could tie this requirement to some sort of reward at the end: for instance, we replace edX/Coursera's "pay for a certificate" model with a "mentor for a certificate" model — meaning you can progress through the whole curriculum without ever joining any cohort or mentoring any student, but you won't be rewarded with anything (certificate or otherwise) unless you contribute by becoming a mentor and grader of other students' work. All mentoring would take place in public to ensure greater accountability of the mentors' work.
  
  
  • What I really like about the above concept is that an OSSU certificate would become potentially much more valuable than a certificate from edX or Coursera. You can basically just buy your way to get a certificate on those platforms without doing much of anything since the grading is usually so lax. For this reason, employers don't really care if you have such certificates. But an OSSU certificate would say that you not only learned the material yourself, but that you have or obtained the soft skills needed to teach it to others. The world needs developers with soft skills; existing MOOC platforms do nothing to improve them. The fact that this certificate would cost $0 is also attractive, because it means lower cost for students and lower financial/legal risk for OSSU.
  
  

Apart from the students, who benefits from building all this infrastructure? What financial incentive is there for anyone to support it? I don't have any thoughts on organization funding at this time, but I would suggest that the people who build it should be students themselves — not some professional contractors, etc. Open Source Society University should be open-source through and through — every project a student produces, all the software they use to produce it, and all the software that runs the school. The act of building it is itself an educational achievement, and those who do will learn the concepts probably much better than the people who are just using it.

Looking for feedback!

[fractalbach]

@hanjiexi

A couple ideas I think should be pursued:

• Online and offline: ... students could meet in physical study groups ...
• Formal organizational structure
• Mentor system
• More active, less passive cirriculum (always a good thing)

I also think it's important to increase communication between students on similar pathways. There could be a system designed specifically for the purpose of grouping people together, and prompting their communication.

Even in online courses for actual credit, online chatter can be low unless it's prompted. I think some icebreakers might be needed :). Anything to rally people together would be a step in the right direction IMO.

On a side note,
I think more programming languages is better than one. How can you find your favorite musical instrument if you only try one? Why force everyone to use only a Swiss army knife to build everything?
Metaphors aside, might be more worthwhile to spend time on the other great ideas you have !

[hanjiexi]

I think my ideas were too forward-looking. No one knows how to respond to something that is still years in the future.

So below I'm outlining my current thoughts for v9-10. (I don't know if everything here can make it for v9, so some of it might have to be delayed.)

I'm limiting this purely to curriculum content and repo organization. Things like mentor systems, projects, offline meetups, organizational structure, etc., will need to be discussed elsewhere.

Each of these points will have an associated issue created for separate discussion. (Edit: links to issues have been added.)

1. I want to give each major section its own page so that the resources can be discussed in greater detail without making the page really long. The main page would just be a guide to the overall curriculum and a table of contents for the remaining pages. #529

2. I want to take "Theory" and split it into "Theory" and "Structures". #525

   • Theory would be used for what is called theoretical computer science, a topic of which we currently have poor coverage.
   • Structures would be used for material covering concrete data structures (e.g. arrays), abstract data structures (e.g. stacks), purely abstract structures like categories (e.g. monoids) or machines (in the mathematical sense, i.e. automata), and theory-focused applications of those structures to the real world, e.g. (theory of) databases, (theory of) networks.
   • Addition of Category Theory to "Advanced Structures".
   • Addition of Purely Functional Data Structures to "Advanced Structures".

3. Arguably, everything in the curriculum is a "system". I want to rename "Systems" to "Machine systems", limiting it to a discussion of low-level systems and their associated DSLs like C. #526

   • Networking should be moved to "Structures" if the material we're using is more theory-focused, but it can be kept if it's implementation-focused.
   • Addition of Rust materials to "Advanced Machine systems".

4. I want to move "Applications" to its own top-level section separate from Core and Advanced for the following reasons. #527

   • "Applications" aren't inherently foundational or advanced by themselves; they each have their own specific learning curve.
   • "Applications" often also have their own specific and unique pre-requisites.
   • By moving out "Applications", we keep Core/Advanced CS just focused on CS.

5. I want to create a section under both "Core" and "Advanced" called "Engineering". Although this will be a bit like the old "Applications", engineering is something that is more general and universal as soon as you're no longer creating toy programs. It would be focused just on processes, good practices, etc. for building larger systems. #528

6. Under "Core Machine systems", I want to replace CS50 with Aalto C since the latter will be more focused on learning C while the former will have the student spending a lot of time learning stuff they already know. #516

7. Move Software Testing and Software Debugging to "Core Engineering" as they are quite fundamental, and move the UBC "Software Engineering" courses to "Advanced Engineering" as they are much more involved. #528

8. Introduction of Parallel, concurrent, and distributed computing in Java to "Advanced Programming".

[ahmadshalabi]

Thank you all to your effort that make such thing exist.

I have two question:
1- How can I helping you?
2- When you will to finish the v9?