Checking:
NR away next week
Can we take extra time today (want to do intro and an exercise)?
Spectrum of courses:
Long-established knowledge that every educated computer scientist should know. Found in textbooks. Taught in required courses.
Established knowledge that many working computer scientists might wish to know. Found in textbooks. Taught as elective courses, but available every year.
Recently discovered knowledge. Found in research papers but not in textbooks. Often taught as special topics (150) or some other numbering suitable for graduate students. This kind of course comes in at least two flavors:
Create new knowledge. Builds on existing knowledge, but by definition, is not found everywhere.
I set up this course with the goal of creating new knowledge about distributed revision control. I believe the most effective means to this end is by applying functional programming. Creating new knowledge is
Especially good for the PhD students---should lead to papers, which is their lifeblood.
Fun for everyone.
Not a requirement: it will be sufficient for you to learn something that is not in the regular curriculum.
Problem: new knowledge builds on existing knowledge
(You have to get to the frontier before you can extend it.)
By and large, the existing knowledge is not published.
And most of you probably need more functional-programming knowledge.
So the plan is something like this:
Learn how to read papers on your own, without a leader.
Read a mix of papers: some advanced functional programming, some in domains related to distributed source control.
Identify an interesting project.
Each of you can pick your own projects; I'm here to help you pick good ones. And you can work in teams of any size. At the end of the term you'll give a juried presentation and about a week later you'll turn in a paper.
What I hope to accomplish today:
Talk about logistics
Explain what our obligations are and how this class is different from other classes you may have taken
Give you a sample of what a group exercise is like
Here's how we'll use our class time:
Analyzing papers. We'll be reading classic functional-programming papers, most of which we'll be really good. We'll also be reading papers about replication, file systems, the merge problem, and particular revision-control systems. Nobody knows if they'll be any good.
We will definitely use the method of "learn to grapple with papers yourself." Even if you're not pursuing a PhD, it's still incredibly useful to be able to read research papers---it's the royal road to learning new technologies and to making yourself more knowledgeable and more valuable to the people around you.
By the way, here's something not everybody knows: reading research papers is hard. Don't get fooled.
Understanding real systems. The things we want to know might not all be published in papers. This is a problem I haven't encountered before, and I don't know how it's going to work.
Project support. We'll probably use class time to help with projects.
To grapple with a paper yourself requires more than 75 minutes.
So we have a special exemption from the registrar to run for four hours per week instead of two and half.
A seminar: collaborative and participatory
150GIT is a dramatically different course. We will still work on challenging problems, but everything else is different:
Focus is on problems you pick (within broad parameters)
Almost no advance script. Instead, . A goal . A native guide through the jungle of unsolved problems
Pace will be less relentless
In 40 and 105, it's already decided what you need to learn, and you learn most of it outside class by doing projects. The role of class time is mostly to prepare you to do this work.
In 150GIT, you will have some choices about what you want to learn:
I hope many of you will choose to learn new things: answers to questions whose answers are not yet known.
You may also have the choice of selecting some advanced topic where answers are known, but you pick the topic you want to learn about.
Most of our class time will be spent in sharing and organizing knowledge acquired outside of class. Rather than simply have some instructor decide, you will work hard to synthesize a coherent picture of what you want to know.
Class succeeds to the extent that everyone is prepared and energized.
Therefore, if you're not on board and active, the entire outcome of the course is changed---everyone loses. This is the single biggest difference from a typical lecture-and-project course like 40.
If you decide to take the course, you have a moral obligation to be a full part of the group, not just a passive observer. (We all work to create what's going on here, and to sit and take would be almost stealing.)
None of the starting-gate exercises count toward a final grade. You will be getting plenty of formative evaluation but little summative evaluation. (A formative evaluation tells you how to make your work better; a summative evaluation tells you how good your work is right now.)
Essentially all your grade is based on the answer to these questions:
Are you prepared when class starts, and are you fully engaged in the group's classroom work?
Have you made a good-faith effort to bring off a quality project? In particular, have you
(Pick any one.)
This kind of effort requires a lot of ingredients:
Have you worked diligently to get youself to the starting gate?
Have you been a colleague with whom to work on projects?
Are you bringing exciting work for the group to hear about? (Anything counts as exciting work as long as you are genuinely excited about it.)
Are you listening carefully to other people's work and helping them to improve?
Can you make a presentation that will impress a jury of talented people from outside Tufts?
Have you written up your work for the archival record, so that you show clearly what you have learned, and so others may be able to build on your work?
I suspect some of this sounds intimidating. Let me assure you it is way more fun than writing problem sets and exams. We've got a huge playground, and you're invited to find whatever you like best on the playground and do something interesting with it.
Final note: within this framework, we can be totally flexible.
In particular, we can steer more toward functional programming or more toward distributed source-code control.
We can decide whether we want to keep a long-term record
Questions for the class:
Do you want to read a paper about the design of combinator libraries? This would include some examples of the role that algebraic laws play in design. (There might be a nice paper from last week.)
Do we want a long-term record?
Exercise: filesystems