September 8, 2005
This course is intended primarily for students majoring or minoring in computer science or information systems. It assumes CSC 171 and 172 as prerequisites. If you're taking 172 concurrently with 270, or if you were planning to take 172 this semester until it was cancelled, you'll have a more difficult time, but you should be able to survive the course; talk to the instructor. This is largely a programming course, so students should expect to spend a lot of time designing, writing, testing, and debugging programs.
If you're taking this course, you are already comfortable with the notion of writing a program, and you've learned some of the techniques and data structures most often used in computer programs. But you've probably only worked in one or two languages (e.g. Scheme, Java, C++, C, Visual Basic), of the literally hundreds of languages out there, each of which has its own strengths and weaknesses. A programmer who approaches every problem by thinking about how to solve it in Java is like a carpenter who uses a hammer on everything, even when a saw or a screwdriver would be more appropriate. A competent programmer must be able to select the most appropriate language for any given problem. Furthermore, a competent programmer must be able to write idiomatically in each language, i.e, to write in the style to which that language is suited: don't be like the carpenter who correctly chooses a screwdriver, but still uses it like a hammer. Finally, a competent programmer must be able to learn a new language and its idiom quickly.
We'll spend the first week or two discussing the history and theory of programming languages, followed by a few weeks on each of five specific languages: C, C++, Java, Scheme, and Prolog. Throughout the semester, you are expected to select and write programs on a self-paced basis to demonstrate your abilities in each language. If you have specific questions about a language based on your reading or programming, feel free to request that I address them in lecture, ideally by e-mail in advance so I have some time to prepare.
I've ordered two textbooks through the Bookstore.
Robert Sebesta's Concepts of Programming Languages. We'll cover only about five chapters of it this semester, but Dr. Chen will cover the remaining chapters of the same textbook in CSC 272 (which most of you are taking) next semester.
Bjarne Stroustrup's The C++ Programming Language. Stroustrup invented C++, almost single-handedly, in the early 1980's, and his book is still the definitive reference on it. He also included a lot of good advice on object-oriented programming and design.
On-line documentation for Scheme at http://www.htdp.org.
On-line documentation and tutorials for Prolog at http://www.amzi.com.
Since all the students in this course have different language backgrounds, I don't plan to give out the same assignments to everyone, due at the same time. Instead, I've posted on the Web a list of skills I expect you to master in each language (as well as a category of ``language-independent skills''). You'll choose programming assignments to do that demonstrate your mastery of various skills. Whenever you turn in a program, I'll go through each of the skills you've demonstrated in that program and assign a numeric score:
0 for ``didn't use the skill''
1 for ``used it slightly or poorly''
2 for ``used it reasonably well''
3 for ``fluent, comfortable, idiomatic''.
These numbers will be multiplied by weighting factors:
``essential'' skills are weighted at 3
``important'' skills are weighted at 2
``obscure'' skills are weighted at 1.
If you demonstrate a particular skill at level 1 on one program, then later turn in another program in the same language using it at level 2 or 3, I'll keep the highest score for that skill. Scores on the language-independent skills will be averaged, rather than keeping the highest. By the end of the semester, you'll have earned a number of points in each language; I'll divide this by the number of possible points in that language, and average together the grades for the five languages, the ``language-independent skills'', and the comprehensive final exam. As a guideline, earning 30% of the possible points in each language is probably a C; earning 50% is probably a B; and earning 70% is probably an A. (There are a lot of features in the list, some of which I've never used!)
You may turn in as many or as few programs as you wish, as long as they are your own work. You may even turn in a program you are also turning in for credit in another course; I'll grade it on your use of the language, which is probably not the central concern in the other course.
However, I don't promise to grade more than one program per student per week, so if you turn everything in at the end of the semester, I'll just grade your shortest program, and throw away the rest. Any homework assignment turned in after midnight, Thursday, Dec. 15 (the last day of class) will earn only partial credit; anything turned in after midnight, Sunday, Dec. 18 will be thrown away ungraded. I recommend starting with the language(s) most familiar to you, and turning in a program or two in it early in the semester.
We'll have a two-hour final exam on Dec. 20 or 22 (I don't know exactly when). The final exam is comprehensive: it may include questions about any of the five languages, about programming languages in general, or about which language you would choose to solve a particular problem.
The final exam must be taken at the scheduled time, unless arranged in advance or prevented by a documented medical or family emergency. If you have three or more exams scheduled on the same date, or a religious holiday that conflicts with an exam or assignment due date, please notify me in writing within the first two weeks of the semester in order to receive due consideration. Exams not taken without one of the above excuses will be recorded with a grade of 0.
Every program must contain, in the first few lines, a comment indicating the name of the student working on it and which assignment it is. Programs not containing this information, clearly visible, will get a zero.
Every program must be accompanied by a session log (I'll show you how to do this) showing how the program works on test cases. Programs with inadequate or poorly-chosen test cases will lose points; programs turned in with no test runs at all will lose lots of points.
Every program must be adequately and accurately commented, as appropriate in the current language.
For those of you who used PSP in CSC 160, 171, or 172, I've set it up (and improved it somewhat) for this class's use too. You are invited to use it to record your time, program size, and defects encountered, but I don't plan to grade it this semester.
Programs are not abstract works of art, they are supposed to run and solve real problems. So if I get a program that doesn't compile or run, I will give it a zero, no matter how much time you put into it. Don't bother turning in a program you haven't tested yourself.
The Adelphi University Code of Ethics applies to this course; look it up on the Web at http://academics.adelphi.edu/policies/ethics.php .
Most homework assignments in this course involve writing, testing, and debugging a program by yourself. You are welcome to seek help on mechanical and syntactic matters (``how do I save this file?'', ``how do I get a session log?'', ``what does this compiler error message mean?'') from me, from other students in the class, and from tutors in the Learning Center; however, for higher-level tasks of design, coding, testing, and debugging, I expect you to work by yourself. If I see that three different people have turned in nearly-identical programs, I'll grade it once and divide the credit among the three, so the best any of them can hope for is 33%.