Skip to content

Instantly share code, notes, and snippets.

@bcantrill
Created December 13, 2012 18:29
Show Gist options
  • Select an option

  • Save bcantrill/4278516 to your computer and use it in GitHub Desktop.

Select an option

Save bcantrill/4278516 to your computer and use it in GitHub Desktop.

Revisions

  1. bcantrill revised this gist Dec 13, 2012. 1 changed file with 8 additions and 1 deletion.
    9 changes: 8 additions & 1 deletion cornellcs.txt
    Original file line number Diff line number Diff line change
    @@ -81,4 +81,11 @@ be blunt, you owe both your undergraduates and your good name much better.
    - Bryan

    ----------------------------------------------------------------------------
    Bryan Cantrill, Solaris Kernel Development. [email protected] (650) 786-3652
    Bryan Cantrill, Solaris Kernel Development. [email protected] (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.
  2. bcantrill renamed this gist Dec 13, 2012. 1 changed file with 0 additions and 0 deletions.
    File renamed without changes.
  3. bcantrill created this gist Dec 13, 2012.
    84 changes: 84 additions & 0 deletions gistfile1.txt
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,84 @@
    From bmc Mon Oct 2 15:12:34 2000
    Subject: Undergrad systems curriculum
    To: [email protected]
    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. [email protected] (650) 786-3652