CSE305, Spring 2007

Course Organization and Policies


Assignments will comprise both pencil-and-paper problems and exercises that require programming. Cheating will be punished, as per department policy (see statements below). All programming exercises must run on the machines yeager/gagarin/armstrong at the time of final submission.

We will try to alternate between "problem sets," with pencil-and-paper exercises submitted in class, and "(mini-)projects" submitted using the on-line submission facility described below. However, sometimes an assignment may have both kinds of exercise, and we currently plan at least one case of one assignment of each type being given out at the same time (with different due dates, of course). Some exercises will involve drawings and formulas that cannot (easily) be written at an ASCII terminal---that is why we expect you to do those in hardcopy.

All submissions must have your name and recitation at the top. Hardcopy submissions with more than one sheet must be stapled together. Must! Staple! Must! Staple! buy a tiny stapler if you're in the habit of doing sets just before they're due.

My (KWR) general policy is that late work is not acceptable. In return, you get an answer key shortly afterward, and a relatively quick turnaround of graded work before the next problem set is due. In an exceptional situation, you may contact me beforehand about a possible extension.

The course will be graded on a total-points system. Letter grades will also be given for individual exams and some assignments, as a help in telling you where you stand, but only the point totals will have official significance. The weighting of grades in this course will be:

  • Homework: 35%
  • Prelims: 30%
  • Final Exam: 35%

Instructors reserve the right to 5% leeway in weighting while assigning the final letter grade&emdash;this is most typically done for students who do markedly well on the final exam, when it may be treated as if it were worth 40% for that student. This will only be done to an individual student's advantage, and will have no effect on others' grades.


Incompletes and Withdrawals

This course shall follow strictly the University's standard for incompletes: they are only to make up work missed owing to circumstances beyond a student's control, and they are given only when a student has enough points to pass the course with already-completed work (i.e., no "I/F" grades).

Academic Honesty

A university is a community, and every community has values and rules that go hand-in-hand with membership in the community. At universities one rule is the standard of academic honesty as it has been understood and followed for all of the just-ending millennium. This rule is not written down in a standard text such as Magna Carta or the Constitution, but is the same for every educational institution even though they all have individual statements of it. The CSE Department now requires that students in every course have read UB's statements of the rules (scroll to "Academic Integrity", and read also this page, scrolling to "Academic Dishonesty"), in addition to the Department's statement.

In this course, all assignments will be individual, and the rule takes a particularly simple form: All assignments must be your own work. This term does not need a definition or legal parsing. We have a whole course, CSE442, to teach teamwork to mature programmers, but 115&endash;116, 250, and 305 are formative courses. Even those communities that gave us the maxim "It Takes a Village..." have instituted and retained solo formative experiences, such as a "walkabout." Even sitting at adjacent terminals in an on-line cafe and sharing routines over a cup of Java is strictly ixnay.

Of course, this policy has to be reconciled with students' desire for help on assignments. The Department has a reasonable guideline tailored to programming projects at the above URL. We will talk about "reasonable discussion" of problems in class at some convenient and good time. Well over half the cases of clear cheating on hardcopy homework that we have caught have been [claimed to be] one student copying off another who couldn't attend class and asked the "trusted friend" to submit for him/her. In such cases both students receive a zero on the set with a notation made in their files; and it is only for "first offenses" of this nature that we tend to show this kind of leniency. If this follows a previous offense reported by a colleague, or for anything more serious or sustained, the student(s) is/are liable for an automatic F in the course and/or explusion from the Department (cum-University).


Sequence of Topics (i.e., "the syllabus"---by intended week order but our mileage may vary)

  1. General concepts, overview and history of PLs (Sebesta chs. 1&endash;2).
  2. Syntax, BNF grammars, with expressions as major example (ch. 3 + parts of ch. 7 that you should already know from 115-116 and 191-192). Recitations will begin contrasting Java (1.5) and C++ with a language "in the middle", namely C#.
  3. BNF, continued: Ada and C/C++/Java examples and insight (ch. 3 + lecture notes).
  4. "Stages of Compilation" (lecture notes); Chapter 4 will be skimmed, with only very light attention paid to parsing. Block structure, variables, and scope (ch. 5).
  5. Subprograms (chs. 5,9,10); Ada and Java compared in recitations.
  6. More on subprograms (ch. 10), start on primitive types (there will be extra ch. 6 notes)
  7. Types (ch. 6); Prelim I covering up thru subprograms. ML will begin in recitations (and lectures) now, if not the week before. References to chapter 15 begin here...
  8. Array, record, and object types (ch. 6). Contrast with lists and records in ML.
  9. Parts of ch. 7 not already handled, then Control Structures (ch. 8), leading to contrast with recursion in functional languages.
  10. Recursion; tail recursion; accumulation style; ML and Lisp. (lecture notes only).
  11. Functional programming; Prelim II will cover up thru there. Begin Prolog in recitations (ch. 16).
  12. Concerted look at OOP and its (current) limitations, anchored to Chapters 11-12 but ranging beyond. Finally differences among Java-C#-C++ in weeks 2--5 will be tied to greater theoretical issues!
  13. Object-oriented programming (chs. 11-12, cont'd); One more language TBA---Erlang would be most thematic with ch. 13 and was covered in Fall 2006, but pleas for Ruby will be heard...
  14. More OOP and current issues in language design---this "Week 14 flex" also allows for falling a week behind this schedule.

Exceptions (ch. 14) will be integrated into the coverage of Ada, Java, C++, and ML between lectures and recitations. Threads (ch. 13) will be covered at the end if time and language-choice allow (it certainly is a major "current issue").