Computer-science: Git and Version Control Systems

[waciumawanjohi]

OSSU previously listed 6 different resources to learn Git. Too many, in my humble opinion. The current curriculum doesn't cover version control systems at all. (In particular, version control is not part of the "About This Course" description for either _Software Engineering: Introduction_ or _Software Development Capstone Project_).

I recommend that we include one course on Git in Core Applications, after _Software Engineering: Introduction_. I recommend _How to Use Git and GitHub_ from Udacity.

[hanjiexi]

Apologies that I am about to steer this topic into talking about what I'm envisioning for some future version of OSSU, but I will eventually address your suggestion.

After I had to manage an employee at my company who didn't understand Git, despite having a Bachelor's in CS, I have very much come around to the idea of integrating some notion of basic tooling into the requirements of the OSSU curriculum.

That would mean not just version control systems, but also things like development environments, APIs, libraries, transpilers, common databases, deployment and workflow processes... of course the trouble with these is that they aren't timeless like most of the curriculum, they are constantly changing, and the particulars are often highly domain-specific.

One of my goals is to clearly delineate the (relatively) "timeless" portions of the curriculum -- theory that will even outlast our lifetimes, which we can call "Category I" -- from parts that are "industry practice" for the near future but far from timeless, "Category II" -- and further from parts that are so ephemeral, they might be outdated by the time you finish the curriculum, "Category III".

Decentralized snapshot-based version control like Git or Mercurial is just graph theory. It becomes significantly easier to understand once one has internalized this. Decentralized snapshot-based version control is also, undoubtedly, industry practice for now, and maybe the next decade or more. (An alternative to snapshot-based would be patch-based.)

Perhaps an elegant way to handle this would be to somehow integrate teaching graph theory with teaching Git. That could mean having Category I content embedded into Category II content, or vice versa. I personally prefer the former: Category I content embedded into Category II content, as then it would be elegant to embed Category I and II content inside Category III content, like so:

MODULE
UNIT 1: Introduce project to solve real-world problem, student attempts a solution using what they know already (Category III)
UNIT 2: Learn new tools that improve student's solution/workflow (Category II)
UNIT 3..n: Learn theory needed to better understand tools and problem domain (Category I)
UNIT n+1: Student solves the problem using newfound knowledge (integration of categories)

Unit 1 would be some project devised by OSSU. Unit 2 would be some recommended tutorials, or maybe short course, such as the Git course you recommended. Units 3 until "n" (however many courses it takes) would be the traditional coursework we already have. And for Unit "n" (the last unit), students would apply everything they've learned, and get graded on the elegance of their solution by their peers at OSSU. An advantage of this approach is that it shows the student how theory is a tool to improve practice -- a tool of tools.

This kind of highly-integrated curriculum program is a long way off for us, but it's something I've been thinking about for the past month or so. It's not going to happen overnight; whatever v8 of OSSU CS looks like, it will probably only be an incremental improvement on what we have now.

On that note, I'm not really convinced that simply sticking a git course into Core Applications solves this in the best possible way even in the short-term. Think of Core Applications as "domains of computer science" -- git is definitely not a domain, but just a tool everyone needs to use whether they understand it or not. In the shortest-term, I think we should just find the best git tutorial on the Internet and link to it somewhere, such as on the CONTRIBUTING page. For the next curriculum version, I hope we can develop some required projects for students, for which they will need to learn and use version control.

[ericdouglas]

@hanjiexi very interesting idea! We certainly can go in that direction.

About the "industry practice" courses, I like to mix these concepts with more theoretical stuff but a recurring thought that always comes to my mind is:

It'd be really great to have a web engineering course, with 80 ~ 90% "industry practice" and 10 ~ 20% CS stuff.

This course should start with the UI layer - UI/UX > HTML > CSS > JS, and maybe finish with one creating their own distributed server with a raspberry pi cluster :)

We should still work on a more "language-level" in such course, so less attention for frameworks, but a deep understand of "how to create such frameworks" so to speak.

I'll add more comments about the Computer Science course later. But one implication of the Web Engineering (WE) course will be to keep the CS one really focused on CS stuff, and the more "practical contents" (industry practice) will stay in the WE.

The format @hanjiexi suggested is still worth for all OSSU courses for sure.

Another idea is to split the CS course and each Advanced CS section will become an independent repository and the CS course will be the Intro + Core section only.

[hanjiexi]

@waciumawanjohi The next OSSU CS update will include two recommended git resources (a book and a course, the one you recommended). Finding a good place to put it is awkward in the current structure; for now it's on the contributing page but in a future update hopefully we can give it a better home by having better coverage of software tooling.

@ericdouglas Those are some great ideas, and my thinking is similar especially on this:

Another idea is to split the CS course and each Advanced CS section will become an independent repository and the CS course will be the Intro + Core section only.

But let's talk about it in a separate topic: #422

[hanjiexi]

One more thing: I talked to the teacher of Software Engineering: Introduction who confirmed that it will have students use git for the course project. They will probably either integrate a git tutorial somewhere into the course sequence, or link to one that they recommend, but since the course isn't out yet they have time to figure out what they're going to do.