The Mathematics Undergraduate Office has a complete set of UW undergraduate calendars from 1970 on. Inspired by some confusion at a Fall 2002 UAPC meeting over the history of how our curriculum has evolved, I went through them. Here is a summary of what I found (with some more recent updates). My personal comments are included in italics.
1970: CS is in the Department of Applied Analysis and Computer Science, and all the Math faculty course descriptions are listed together under "Mathematics", something that continues until 1990 (though in 1977, they are at least grouped by department within Mathematics). There is a course numbered 340, "Computer Systems", and one numbered 471, "Computer System Organization and Logic Design". The basic design of required courses through 3rd year and optional courses in 4th year continues until the introduction of the BCS in 2001-2.
1972: 340 is split into a) and b), a) being Machine, Data, and Program Structures, and b) being Implementation Schemes for Programming Structures (this including things like searching, sorting, run-time representations of HLLs, dynamic storage management, and text manipulation).
1973: 471 becomes 371 a) and b), respectively Switching Circuits and Computer System Organization and Logic Design. 474 b Principles of Operating Systems is introduced (a is a numerical analysis course) with prereqs 340 a,b.
1974: 371b becomes Architecture of Computers. At this point Computer Science becomes a separate department in the Faculty of Mathematics, but all courses are still listed together.
1975: 371 becomes Digital Networks. 471 a) Computer Architecture is introduced, and recommended as a prereq/coreq for 474b (OS).
1976: 340 a,b become 340 and 342, but otherwise stay the same. Digital Networks is renumbered 369, Architecture 450, and Principles of OS 454.
1977: 250 Characteristics of Computers is introduced. This covers machine and assembly language programming, basic architecture, subroutine linkage, macro instructions, loaders, I/O, operating systems, peripherals. 342 (Implementation Schemes for Programming Structures) is eliminated; 350 Machine Structures is introduced, covering basic operating systems material. 454 remains as a second OS course. Courses are now split apart by department in the calendar, but all Math departments have adjacent listings under "Mathematics" in the alphabetical listing, done otherwise by department.
[This was the year I started as an undergraduate, and the first courses were 180 (Cobol) and 140 (Fortran with numerical applications). Both were required, but could be taken in either order; those in co-op were either strongly encouraged or required to take 180 first. The second year contained 250 and 240 (which covered much of the material in the old 342 or 340b: elementary data structures, parsing, text manipulation with SNOBOL, memory management), and then there were six 3rd year courses. There followed a period of remarkable stability until 1982, just long enough for me to get my degree. Note that throughout this period, 48 credits were required for an honours degree, a course load of six courses a term, and CS specified courses through the end of third year (six required 3rd year courses -- two numerical analysis, 340, 350, 360, 369). There were also five math courses required from a short list. The general degree in CS required 42 credits.]
1983: 350 was removed and 354 Software Systems was introduced, covering operating system services, file systems, linkers, loaders, libraries, monitors, debuggers, interrupt handling, process communication and synchronization. 454 stayed unchanged, and there may have been some overlap: its description mentions memory management, processor scheduling, atomic actions and system structure, and concurrency control.
1987: This is the last year for the old 140, 180, 240, 250. 454 becomes Distributed Systems. This is also the year that CS moves to a 44-credit degree (honours only, general was eliminated, because the provincial government funded it at half the level of honours); PMath had been at 44 for some time. This results in a squeeze in third year, and the number of numerical analysis (becoming scientific computation) courses in the core moves from two to one. But there were no changes in the courses discussed here.
1988: The first year of a completely revised first and second year, which would turn out to be an unfortunate mistake. 131, 132, 241, 242 are Principles of Computer Science 1, 2, 3, 4. The first two courses are broad overviews of CS; 241 is similar to what it is now, and 242 is described as "the function of modern operating systems and relationship to the computer architecture that underlies their implementation, including file systems, I/O and interrupt handling, CPU scheduling and swapping, memory management, parallel processing. The course also includes an overview of computer networking, performance monitoring, modelling and simulation, and social implications of computing."
[I joined the faculty in 1988, and was brought onto the teaching team for 131 in 1989 in order to succeed Jay Black as course coordinator (he took a year's sabbatical and never returned to the course). These courses (131 and 132) were disastrously shallow, working neither on their own nor as support for following courses, and I worked hard with others to get rid of them, though it took a while.]
1989: CS completed the move to a 40 credit degree, with three 4th year courses required, and the math shortlist still in place. David Taylor is Curriculum Chair at about this time.
1990: CS finally has a separate listing of courses under "Computer Science", something that other departments outside Math have had for a long time.
1992: 130 and 134, fairly close to what the ACM Computing Curricula terms CS1 (programming) and CS2 (elementary data structures) courses, are introduced to replace 131 and 132. Forbes Burkowski is Curriculum Chair, having gotten the job because he showed interest in curriculum by bringing forth a proposal to teach a course out of the book "Concrete Mathematics". [However, his new duties precluded him from teaching the course, and I got to teach it. It was a lot of fun, but I recommended that it not be made part of the regular curriculum. This isn't usually what happens; people push hard for courses they can "own", and it gets very difficult to remove anything from the curriculum once it is there.]
1993: 246 (Software Abstraction and Specification) is introduced. This is the result of a considerable amount of discussion within the department over what programming languages should be taught in the first and second years and when they should be introduced, as well as concern on managing the transition from Macs in first year to Unix in subsequent years. Peter Buhr wants to have the second language be C++ and to convert 242 to a concurrent programming course using his research system uC++; others want C++ in first year, or to avoid C++ entirely by using languages such as ML. Eventually the department settles on Pascal in the first year, Modula-3 in second, and C++ starting in third year with a revised 242, which in this calendar is called 352 Concurrent Programming but otherwise has the same description as the old 242. (Due to the math core, there is room only for two 2nd year CS courses.) Peter's interest in curriculum gets him the job of Curriculum Chair.
1994: 352 is renumbered 342 and given exactly the same calendar description that it has as 343 today.
1997: The math shortlist for CS is removed; now the degree requirement just says "two credits (four half-credits) in Math but not in CS". Nick Cercone is hired from Regina as Chair of Computer Science, the first external hire of a chair in the history of the department.
1998: [That fall, I became Curriculum Chair after my sabbatical, succeeding Peter Buhr, who had had the job for four years.] Java is introduced in first year in 130 (later 133); the pilot and first main offering resemble earlier offerings of 130, though the course would later drift to an objects-early approach with an in-house textbook. C++ replaces Modula-3 in 246, which becomes a successor instead of predecessor to 241; the Unix tools focus had evaporated with the departure of designer Mike Coffin and the switch (which gave 241 the introduction-to-Unix role). 340 is moved down to second year and becomes 240, as Ian Munro campaigns, on a Faculty committee, to have the math core reduced.
1999: The removal of Calculus 3 from the math core (either it or C&O 239, which became Math 239, are required) allows the introduction of a fourth second-year course, and 351 (Digital Design) is moved down to become 251. The Bioinformatics program is approved. Nick Cercone and Tony Vanelli (ECE chair) press for a joint program in Software Engineering, based in part on the Software Engineering Option jointly designed by the two departments during Peter Buhr's term as curriculum chair. After much heated discussion, the SE program is approved by both departments, and the new degree of Bachelor of Software Engineering is created.
2001: Redesign of 251 as Computer Organization and Design, with less low-level digital design and more architecture, including the beginning of OS material (paging, caches), which fixes the anomaly of talking about paging algorithms in 240 but not understanding the context until 354. [I did this, wearing my hat as 251 instructor, against the wishes of the original designer of 351, and with the 251 course coordinator remaining neutral. The current 251 is essentially unchanged from this design.]
Nick Cercone declines a second term as chair, citing frustration
with the relative inability of CS to control its own budget,
admissions, and curriculum; a reform movement leads to the creation
of the School of Computer Science and the conversion of Math
Faculty Council from a committee of the whole to a representative
structure. Frank Tompa begins a two-year transitional term as chair
to set in place a new administrative structure within the School.
2002: Approval of the BCS, with a CS core consisting of two first-year courses, five second-year courses (up from four), and two third-year courses (down from five), followed by six more CS courses. The extra math requirement is eliminated for the BCS and strengthened for the BMath to something resembling the original shortlist. 360, 370, and 342 are removed from the core; 354 becomes 350 and now precedes 342, which becomes 343, with little or no change in design. 245, based on SE 112 from the joint software engineering program, is added to the CS core.
2003: The job of Curriculum Chair is merged with the job of
Undergraduate Operations Chair (held by Arnie Dyck for many years),
and Mark Giesbrecht becomes the first Director of Undergraduate
Studies; the Curriculum Committee is renamed the Undergraduate
Academic Plans Committee. Attention focusses on first-year CS: David
Taylor, as Associate Dean of Undergraduate Studies for the Math
Faculty, is alarmed that most students are opting for an ostensibly
remedial three-course Java sequence in first year (a de facto
increase in the Math core) and instructors of upper-year CS courses
report weak programming skills. [Part of the problem was an
entrenched first-year course structure operating without CC/UAPC
oversight, and reluctance on the part of most faculty to get
involved in teaching these courses. I proposed a parallel course
structure using Scheme as a first programming language.]
2004: 135 and 136 are approved, offering all students in the Math Faculty a choice between two approaches to CS for the first time in the history of the Faculty. 135 is first taught as a pilot section in fall 2004, with 136 taught the following winter. [I designed and taught 135; Mark Giesbrecht designed and taught 136; we worked closely together.]
2005: The remedial 131-132 sequence is replaced by 125, and 133 is redesigned; both courses, taking an "objects-middle" approach using Java, debut in the fall under new management. Naomi Nishimura succeeds Mark Giesbrecht as Director of Undergraduate Studies. [125 is designed specifically for non-majors, but it feeds into 134 along with 133, and 134 does not change, so failure rates rise. Meanwhile, enrollment in 135 doubles every year.]
2008: A subcommittee of CC/UAPC decides to delist the Java-based courses. The major sequence 135-136 is augmented with 115-116 designed for nonmajors. 115 is about 2/3 of 135, and 116 uses Python. Naomi Nishimura and Dan Brown pilot the first versions of these courses. Naomi Nishimura's attempt to rationalize the non-core third- and fourth-year CS courses fails at School Council. In place of the fast-track to 134, 145 is introduced for students with aptitude (not experience), which leads directly to 241.
2009: Frank Tompa succeeds Naomi Nishimura as Director of Undergraduate Studies. He had been opposed to all changes since before 1999, and this brings an end to curriculum reform. 246 and 241 change places yet again; nothing else changes on his watch. [In a form of devolution, 246 becomes a "programming in C++" course; 136 becomes a "programming in C" course; and 116 becomes a "programming in Python" course, all of which pretend that 115/135 do not exist. I propose 146 to follow 145, to make the enriched sequence more accessible and save non-CS majors from 246, and miraculously this is approved. There are no further changes to core CS courses. Other non-core CS courses are added at third- and fourth-year levels, but none are removed.]
2015: Fears of losing good CS students to other Math departments prompt the introduction of second year "E" courses, enriched versions of the core courses. These are piloted with 240E and 241E before they appear in the calendar. 240E just presents more data structures and analysis, but Ondrej Lhotak designs 241E as a new course with new ideas. [Heartened by this, I design 245E as a new course, and build a new-course version of 240E. Materials for these and some of my other course offerings are available elsewhere on my Web site; they were not taken up by any other instructors, and no one has taught 241E besides Lhotak. 246E and 251E are later approved, though 246E is simply more/faster C++; 251E has yet to be offered, and may never be.]
Note added in 2022: Ballooning enrollments have turned most CS core courses into large machines which turn the crank on the same materials term after term, with very little prospect of reform or reconsideration. The first two years are almost entirely taught by lecturers and sessionals, with almost no research faculty involved (a considerable change from my undergraduate years and my early years as a faculty member). Fourth-year courses are largely designed to get undergraduates to stay on at UW as graduate students of the instructor. The university keeps introducing new programs which select from the existing palette of courses, with possibly a couple of new specialist or capstone courses at the fourth-year level, but there are no rewards for maintenance or upgrading of existing programs. Is this the end of history?