This course gives students the following skills:
Consider the plight of a student who wants to learn how to build a Web
application. Web apps rely on multiple technology layers working
reliably together 24x7. To be successful, a student will need to learn
a bit about Unix, a bit about a relational database management system, a
lot about engineering the Web server object itself, proficiency in some
scripting language, the basics of HTTP, a bit about administering
permissions and configuration of a Web server, the syntax of HTML, etc.
- ability to distinguish between good and bad Web service ideas
- the technical ability to build any of the sites that are currently
live on the public Internet, with one set of tools
- an understanding of Web standards and an ability to apply that
understanding to practical publishing problems (e.g., "why isn't my site
being indexed by public search engines?")
- ability to effectively use a relational database management system
to support Web-based collaboration
- ability to construct an ecommerce service from scratch
At most colleges today, there is no way to learn all of these skills via
the current curriculum. Even at schools where there are a lot of
practical classes, the student would have to sit through three semesters
before being able to serve a single page: Unix, C/C++, database,
relational database management systems and SQL, object-oriented design,
networking protocols, Internet protocols.
This course gives a student everything that he or she really needs to
know. Some of the stuff is deep. For example, a Web server is an
object. It has internal state, whose persistence is typically achieved
via a relational database management system (e.g., Oracle). The methods
are the URLs and the arguments to those methods are the form variables
on the pages that target those URLs. Engineer will have to design
future Web services so that their methods can be invoked by other
services across the public Internet. Some of the stuff is shallow. The
student needs to learn how to use Emacs, that typing "sqlplus" into the
Unix shell is a way to connect to Oracle, that HTTP mandates headers
separated by CRLF, then two CRLFs, then the page content.
By the end of this 13-week course at MIT, all of the students have built
Web applications that compete with the best commercial Web services (but
without the ugly banner ads). See arfdigita.org for an example.
Isn't this too much practical stuff?
Some CS faculty have looked at this course and said "We love the deep
concepts and the high-level stuff but we shouldn't have to teach
students how to use Oracle or any other real system." People think this
course is too practical or just right depending on their conception of
what happens when a student graduates.
In the Good Old Days our students would graduate and go to work for a
large company where they would be a junior programmer. They'd spend
five years learning to become an engineer from the experienced folks in
their large organization. At age 28, they would begin to take on the
role of senior developer or system architect. In the current world,
however, a top MIT CS graduate will go right into a venture
capital-backed .com startup as the Chief Technology Officer or senior
developer. Our graduate will have to translate business requirements
into technology decisions and won't be able to ask advice from more
experienced people in their organization.
So the question is "Do we want to give MIT master's degrees in computer
science, from the School of Engineering, to people who do not
have the foggiest idea of how to engineer the kind of information
systems that society wishes to build?" My answer is "No!" and "Here's a
course that will at least familiarize students with the major challenges
that they'll confront in the next 20 years of their careers and some
ideas and technology that can be applied to meeting those challenges."
This is a senior-level class at MIT where we expect the average student
to be working on a bachelor's or master's degree in computer science, to
have taken our introduction to computer science (6.001), to have taken
our core software engineering class (6.170), and to have done at least
some programming during summer jobs.
That said, the class does not require any knowledge of particular
computer languages or systems. I.e., the students will learn enough
about the required tools as the course progresses.
Adoption by Universities and Companies
This course is designed for easy adoption by other universities. We
provide the following materials online for free:
You will need to set up a Unix/Oracle server on which your students can
work. Linux is fine (though at MIT we use Solaris). A single pizza-box
Unix machine ($7000) or modern Pentium supports 30 students nicely if
you have at least 512 MB of RAM. If your school isn't already
site-licensed for Oracle, you can usually get a free or good deal from
the Oracle folks (they like to support teaching of Oracle skills in
- three textbooks
- problem sets
- lecture notes
- (eventually) video lectures (Web streamed, DVD, or VHS tape)
This course was developed by Hal Abelson (firstname.lastname@example.org), Michael Dertouzos
(email@example.com), and Philip Greenspun (firstname.lastname@example.org).
Bottom line: about 500 CS majors have gone through this curriculum and
all but about 15 have become competent database-backed Web service
- Spring 1999: offered as MIT course 6.916: Software Engineering of
Innovative Web Services (3-0-9).
- Summer 1999: offered as an intensive summer course at University of
Hamburg and New York University, as a 5-week boot camp (three psets plus
Unix sysadmin and Oracle dbadmin), and as a 2-week boot camp (psets 1
- Fall 1999: adopted by California Institute of Technology; offered
again as MIT course 6.916
- Winter 2000: offered as an intensive 9-unit course during MIT's IAP;
- Spring 2000: repeated as MIT course 6.916, offered to remote
students at UC Berkeley (thanks to Doug Tygar (email@example.com) and
Stanford University (thanks to Jeff Ullman, firstname.lastname@example.org)
- Spring/Summer 2000: offered as CS190 at UCLA, taught by Robert
- Summer 2000: adopted by University of Michigan, taught by
- June-December 2000: adopted by UFM
(Guatemala City, Guatemala), taught by
- Spring 2001: planned offering at University of Pennsylvania
by Michael Greenwald
- February - June 2001: planned offering at
University of New South
Wales (Sydney, Australia), led by
Basic Course Structure
You will want a laboratory where all the students can work together, one
terminal per student. The terminal should be capable of running ssh (to
connect to the development), an X server (for convenience in using
Emacs), and a Web browser such as Netscape Navigator. At MIT, we use an
Athena classroom or cluster where each terminal is a Unix machine.
Linux is fine and Macintosh or Wintel PCs are also fine if you install a
bit of extra software.
- Lectures: 2 hours per week
- Public Site/Code Review: 1 hour per week
- Supervised/Cooperative Lab: 6 hours per week
For the lectures, you'll want a room with a good Internet connection and
video projector so that all the students can see one Web browser.
Most of the work and learning happens during the problem sets. Ideally,
the teaching assistants should be experienced software developers, e.g.,
volunteers from industry. The TAs and students sit side-by-side at a
terminal and discuss approaches to a problem. This is the only way that
we know of to teach students to build tasteful maintainable code.
If you have advanced students and a lot of TA resources, try to get
through the problem sets early in the semester and then let students
build projects in teams of two or three. We did this at MIT the first
time that we taught 6.916. It worked pretty well except that the
students weren't educated to a very uniform standard. The ones who were
strong programmers coming in were strong programmers going out; weak
programmers only got a bit better. The students who worked on good
project ideas with helpful clients did great work and learned a lot;
students saddled with weak project ideas or indifferent clients were
frustrated and didn't get much out of the project.
Here are some options:
- strong students, lots of TAs: 3 psets spread out during the first
six weeks; projects during the last six weeks
- strong students, few TAs: 5 psets spread out over the entire term
- weak students: 4 psets spread out over the entire term
- intensive summer program: you want to do boot camp (2-, 5-, and 12-week options)
Add a comment | Add a link