An old e-mail to the Cornell CS faculty; have things changed in the last 12 years?

cornellcs.txt

From bmc Mon Oct  2 15:12:34 2000
Subject: Undergrad systems curriculum
To: faculty@cs.cornell.edu
Date: Mon, 2 Oct 2000 15:12:34 -0700 (PDT)
X-Mailer: ELM [version 2.4ME+ PL31H (25)]
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Content-Length:  4065
Status: RO


Cornell CS faculty,

I work in Solaris Kernel Development at Sun Microsystems.  Recently,
I (along with another engineer from Solaris Kernel Development) interviewed
students at Cornell for both full-time and internship positions within
our group.

While the students we interviewed were clearly bright and motivated, they
were woefully unprepared for the design or implementation of computing
systems.

To elaborate:  our most coarse-grained filter for assessing preparedness is
to ask the candidate what (in the absence of compiler optimizations) the
following C program does:

        int
        main()
        {
                int *x = NULL;
                int y = *x;
                ...

This is not a trick; I expect one hundred percent of graduating seniors in
Computer Science to be able to answer this question.  Indeed, we only ask
this question as a segue to more subtle issues:  I expect candidates to be
able to write the program in the assembly of their choosing, and -- assuming
they have had an OS class -- be able to discuss in some detail the hardware
and software which lie between loading from an invalid address and the
ensuing death of the incurring process.

At Cornell, all of the students we interviewed had taken 414 (and many
had taken 415), but most students gave us the response "y gets zero" (with a
sizable minority telling us that the program would "throw a NULL pointer
exception").  Obviously, neither is correct(*) (though at least the second
is in the ballpark).  Further probing, however, revealed that even the
students who gave the second (Java-centric) answer had virtually no
understanding of OS implementation, or (more generally) of the interaction
between hardware and low-level system software.  And most disconcertingly,
the students with no understanding of OS implementation included a
TA for 414.

Surprised by the anemic preparation of otherwise high-caliber students,
we asked about the specifics of the Cornell CS curriculum in general and
about 414/415 in particular:  we were astonished to learn that 414
has no implementation requirement, and that the implementation in 415
consists largely of a disk simulator written in Java (it has been our
experience that even a featherweight OS course requires some implementation
in Nachos or equivalent).  Even more surprising, students graduating with
a CS degree from Cornell _never_ learn C or C++ or Pascal or _any_ language
that deals with memory explicitly.  Just as the revolution in structured
programming languages did not push machine architecture out of the
undergraduate curriculum, so should the proliferation of Java not displace
the teaching of lower level systems and languages.  By purging this
technology tier from your curriculum, you are generating students who are
thoroughly confused and completely unprepared to develop any core
technology (after all, JavaVM's aren't written in Java).

And should you think me unfair:  we ask the same questions at every school
at which we interview.  At schools with superlative OS courses (Princeton
and Brown come to mind), _every_ candidate blows this first question out of
the water (after all, it _is_ the "gimme" question).

So why am I wasting my time writing you?  We won't recruit at Cornell again,
so there's nothing in it for us.  But we just met too many generally
bright, grossly underqualified students who were allegedly interested in
systems implementation to not make you aware of your acute problem.  To
be blunt, you owe both your undergraduates and your good name much better.

        - Bryan

----------------------------------------------------------------------------
Bryan Cantrill, Solaris Kernel Development.  bmc@eng.sun.com  (650) 786-3652

(*) On some (horribly ill-advised) operating systems, 0x0 is mapped to a
zero-filled page (IBM's AIX is the most famous example; there are other
more obscure examples).  When students give the response that "y gets zero",
we immediately ask them to qualify it with an operating system.  Suffice it
to say, none of the Cornell candidates qualified their answer with an
operating system which maps 0x0.

Was a response received?

ans: co' dump. (golly!)