Comment by learc83 | Hacker News Reader

Comment by learc83 | Hacker News Reader

Parent Full thread

>CMU doesn't generally craft their degrees for industry-marketability;

I don't think a CS degree should be a trade program, but avoiding actively harming students job prospects by adding a few more electives isn't quite the same things as crafting their degrees for industry-marketability.

>they tore out functional programming above 15-150

I'm looking at the requirements for the BS in CS right now. I don't see any function programming requirements above 15-150.

>OS, and Networking

It looks like neither is required right now. Here's the relevant section.

    Choose 1

    15-410: Operating System Design and Implementation

    15-411: Compiler Design

    15-418: Parallel Computer Architecture and Programming

    15-440: Distributed Systems

    15-441: Computer Networks

    Others as designated by the CS Undergraduate Program

> if they bent the CS degree instead of introducing a new AI degree, could higher-learning institutions continue to trust that a CMU CS undergrad had a solid foundation in functional programming, discrete mathematics, and systems theory?

Looks like the functional programming, and discrete math requirements are the same.

Systems is an overloaded word, so I'm going to assume you mean software systems, since that requirement is what is removed. The systems requirement is already just chose one from above list. I don't think taking 1 network class means you have a solid foundation of systems theory.

I stand corrected: since I took the curriculum, functional programming requirements seem to have been substituted with an option to do higher-level systems-engineering electives (such as 15-414). And the systems elective has been expanded to include parallel and distributed systems.

The key difference on the deep-theory side is that CS and AI appear to swap out deep-diving into discrete math for deep-diving into statistics and statistical modeling. I'd consider those different enough to warrant separate degree tracks, personally.

(Your opinion of networking is noted but I do not share it, being somewhat familiar with what that course asks of students. It's every bit as preparatory as its sibling 15-410 class ;) ).

>The key difference on the deep-theory side is that CS and AI appear to swap out deep-diving into discrete math for deep-diving into statistics and statistical modeling. I'd consider those different enough to warrant separate degree tracks, personally.

What discrete math classes were removed from the AI degree?

>(Your opinion of networking is noted but I do not share it, being somewhat familiar with what that course asks of students. It's every bit as preparatory as its sibling 15-410 class ;) ).

I looked over the syllabus and assignments for a section of that class. It looks like a bog standard networking class (bog standard for top tier schools that is). It's an elective. You can take an OS class, a compilers class, or a networking class. I don't think there is some intersection of knowledge/skill between those 3 classes, the absence of which would give higher-learning institutions pause.

My institution required that you take both an OS and a networking class before being admitted for graduate study. It's one thing if they require OS, and networking, and compilers. That they don't do that says to me that they don't consider them critical classes, since any given graduate could be missing any 2 of them.

We actually have a set of criteria for what makes a qualifying systems elective. As with many things at CMU, we don't generally care what details you learn. We care greatly what higher-level concepts you get exposed to, and the systems courses are the place we try to focus on the development of abstractions; modularity; isolation; reasoning about failures and complexity; integrating security concerns. They're also the courses where students are required to work on projects large enough to blow out their cache -- multi-week or month projects that force you to think reasonably about how you divide your design into pieces so that you can coherently reason about the ensemble.

We're pretty much equally happy if you hit layering in the network class or thinking about the filesystem and kernel VFS layers in the OS class - or the modular structure of a modern compiler. Tackling the idea of reliability through replication in distributed systems (via a lot of different mechanisms, but with a decent dose of Paxos), or via the Reliable Storage module in 15-410, or in DB. Getting additional hardware architecture exposure through compilers or the parallel class. Thinking about communication using a fast local interconnect (parallel), the internet (networks & DS), or IPC (OS). Compilers can be more or less of a systems course depending on who teaches it, but it's generally got such a strong architectural component that it flies.

It's much like programming languages. We don't care much if you graduate knowing a particular language -- any CMU CS graduate should be able to pick up a new language in short order. We care greatly that you've been exposed to a mix of programming styles and thinking -- imperative, functional, and logical or declarative, and can successfully use those tools to reason about code, program structure, algorithms, and data structures.

So no, we absolutely don't consider it critical that you take any specific systems course, but we do consider it critical -- for the CS major -- that you be exposed to the broad set of systems concepts we teach in them. That's why we start them in 15-213 and then reinforce them with one upper-division systems elective requirement.

>It's much like programming languages. We don't care much if you graduate knowing a particular language -- any CMU CS graduate should be able to pick up a new language in short order. We care greatly that you've been exposed to a mix of programming styles and thinking -- imperative, functional, and logical or declarative, and can successfully use those tools to reason about code, program structure, algorithms, and data structures.

I completely support this philosophy.

> Compilers can be more or less of a systems course depending on who teaches it

So what happens when it's less of a systems course? Do students taking that section lack a critical component of the CS major?

We encourage it back towards systemsy-ness. ;). (in other words - nothing's perfect, and we accept some occasional compromises in service of providing a diverse menu. Compilers has other value. If it got too PL-centric, we would just move it to the PL cluster, but it's generally stayed systems for the last decade.)

The logic and languages cluster, while not exclusively a functional programming set, practically covers a lot of what one might think of as upper-division FP concepts. Foundations of PL and Semantics are bread and butter PL theory, for example.

But none of those are required in that section. You could take Software Foundations of Security and Privacy, or Foundations of Cyber-Physical Systems.

Funny you'd pick those two. :-)

Software Foundations includes, for example, the use of type systems to ensure bug-freedom, program semantics, and more. Matt Fredrikson focuses on the intersection of formal programming languages research and security. For example, lecture 3: https://15316-cmu.github.io/lectures/03-safety.pdf

Cyber-physical is one of the hardest classes I've ever seen. Seriously - it combines very solid differential mathematics with logic and formal verification. It's a different set of skills than Semantics, but it combines a really solid dose of the same kind of logical and proof-centric thinking that advanced PL courses do. And rapidly runs into the logical underpinnings of both fields. For example, lecture 13: http://symbolaris.com/course/fcps16/13-diffchart.pdf

(In large part, this is because the course relies on identifying PL-style semantics of differential systems, and thus, students in the course end up being exposed to nearly identical proof methods as they do in the more straight-up PL semantics course, in addition to a lot of differential equations.)

It does look like there are portions of those classes that are similar to a PL semantics course, which in turn covers some of the concepts you'd cover in an upper-division FP course. It's still a bit of stretch.

After I looked over the assignments for a section of Software Foundations, I don't think that taking an AI class instead would make much of a difference when it comes to having a solid foundation in functional programming, which is what the GP was talking about.

15-210: Parallel and Sequential Data Structures and Algorithms, which is still required, is purely functional.

That class is also required for the AI degree.

That's actually what I meant, but used the wrong phrasing - I can't edit it, unfortunately.

Reply on news.ycombinator.com