Fall 2018: Course Syllabus¶

Instructor: TA: Jack Rosenthal (jrosenth@mines.edu) Ben Tarman (btarman@mines.edu) Christopher Painter-Wakefield (cpainter@mines.edu) [1] Tuesdays and Thursdays, 9:30 AM to 10:45 AM in MZ 235 See the course website for a current schedule, or Email to schedule appointment. https://lambda.mines.edu CSCI-306 (Software Engineering) CSCI-274 (Intro to Linux) – see Expectations for more info.
 [1] You probably won’t ever need to contact the course adviser, but if you have concerns you wish not to bring to the attention of the instructor (e.g., anonymous concerns), you are welcome to contact the adviser.

Course Description & Learning Objectives¶

CSCI-400 is a course covering the design and implementation of computer programming languages. This topic is highly relevant for both future software engineers and computer scientists: by exposing oneself to how programming languages are made, software engineers will be able to learn new programming languages in their profession to adapt to rapidly evolving technology, and computer scientists will explore a practical usage of computational theory.

By the end of this course, students should be able to:

1. Explain common programming language concepts, such as evaluation order, typing systems, memory management, paradigms, scoping, tail recursion, etc., and identify their usage in industry programming languages.
2. Use mathematical foundations of the lambda calculus to define programming language constructs.
3. Understand language-oriented programming by implementing a domain-specific programming language.
4. Implement an interpreter for a non-trivial programming language.

To fulfill these learning goals, we will use numerous programming languages during the course, including many dialects of the Racket programming language, and Python. Students will be given multiple projects and homework assignments that relate directly to these goals.

Expectations¶

Students are expected to develop all code for this course using a Linux machine. Basic familiarity with the Linux command line is assumed: CSCI-274 (Intro to Linux) is highly recommended (even as concurrent enrollment) if the student is not already familiar.

Students are welcome to develop either on their own Linux computers, or at the Linux lab provided by the school: ALAMODE. ALAMODE is located at BB 136 and you can login using MultiPass credentials.

Students are expected to have familiarity with either C or C++ before entering this course. Note that no C++ code will be used, we will only be discussing C, so knowledge of C++’s more advanced structures (such as classes, templates, etc.) is not strictly necessary.

Learning Groups¶

This course makes use of learning groups to facilitate education. You will be randomly assigned a new learning group every few weeks, and your instructor will let you know your new group via Email. You are expected to:

1. Sit with your learning group during lecture.
2. Complete your part of learning group assignments, dividing problems amongst group members if requested by the assignment.
3. Share results from learning group assignment at the beginning of lecture with the rest of your group.

Part of your grade will be derived from the average quiz scores from your learning group (missing, zero, or significantly outlying quiz scores will not be included in this average unless they are your own). You should make sure to study with your learning group members and help them understand even if you think you know the material. Teaching is the (hidden) highest level of Bloom’s Taxonomy.

If you have issues with any of your group members, you should let your instructor know so that groups can be reassigned.

Most programming assignments are automatically graded upon submission. The grading scripts are designed to mark all fully-correct programs as correct, and do the best job possible assigning partial credit where applicable. But under some cases, you may not receive as many points as you deserve. If you believe this to be the case, contact the course instructor so they can either fix the autograder to handle your case better, or manually grade your assignment.

You are only allowed 4 submissions on autograded homework. This is because your grade is received quickly after submitting, and it may be tempting to use the autograder as the only means of testing. Students are expected to test their own code before submitting. If you run out of submissions and need more, then contact the instructor.

Warning

Autograded assigments are reviewed for plagarism a few weeks after the deadline, not when graded. While copying an assigment from another student may give you a good grade in the short term, the long term consequences could be severe. Plagarism is taken very seriously on these assignments.

 Learning Group Participation 5% Homework 25% Quizzes (Individual Grade) 28% Quizzes (Learning Group Average) 7% Language Explore Project 11% SlytherLisp Project 24%

All assignments within the homework and quiz category will be weighted equally, regardless of the number of points listed on the assignment. Some more involved assignments may specify they are worth a certain number of assignments (for example, an assignment may be worth two assignments).

There will be approximately 8 quizzes during the semester, plus or minus two.

Your grade letter will be derived using the standard plus-minus grading scale. In other words, if your grade in percents is $$X$$, then your grade letter will be:

Grade If $$X$$ is…
A+ [2] $$X \geqslant 96.5$$
A $$93.5 \leqslant X < 96.5$$
A- $$90.0 \leqslant X < 93.5$$
B+ $$86.5 \leqslant X < 90.0$$
B $$83.5 \leqslant X < 86.5$$
B- $$80.0 \leqslant X < 83.5$$
C+ $$76.5 \leqslant X < 80.0$$
C $$73.5 \leqslant X < 76.5$$
C- $$70.0 \leqslant X < 73.5$$
D+ $$66.5 \leqslant X < 70.0$$
D $$63.5 \leqslant X < 66.5$$
D- $$60.0 \leqslant X < 63.5$$
F $$X < 60$$
 [2] For some reason, I cannot put this in Trailhead. But you will still get the bragging rights.

Late Work Policy¶

This course uses a slip day policy. Every student starts the semester with eight slip days.

For each 24 hours you turn in an assignment late, it will cost you 1 slip day to turn in an assignment. You will not get any points off, you just need enough slip days to turn it in. For example, if you have 3 slip days left, and you turn in an assignment 4 hours late, you will have 2 slip days left after turning in the assignment.

Slip days can only be used for homework assignments and for deliverables on projects. You cannot use slip days for quizzes or learning group activities.

Regardless of how many slip days you have, the following rules apply:

1. No more than 5 slip days may be used on a single assignment without the instructor’s permission.
2. You must turn in all work by midnight on Dead Day, even if you still have slip days left.

Students are expected to keep track of their own slip day balance, and indicate the number of slip days they are spending on an assignment when they turn it in. For printed assignments, this should be at the top of the page, and for programming assignments, this should be in a comment at the top of the source or in a README file.

If you are running low on slip days and need more (for example, for a school-sponsored athletic event or medical condition) you are welcome to contact the instructor and ask for more.

Give me the TL;DR

You have eight slip days. Each 24-hours costs you one slip day. Keep track of your own slip days, and indicate the number you are spending when you turn in the assignment.

Missed Quiz Policy¶

If you cannot make a quiz, simply email instructor in advance and we will schedule an alternative time. This does not count towards the below policy.

If you forget a quiz (e.g., oversleep an alarm), you are allowed to makeup a quiz once, only if you contact the instructor within 24-hours of the missed quiz! The instructor may exempt this rule for extenuating circumstances.

Collaboration Policy for Programming Projects in CS Courses¶

The following policy exists for all courses in the CS department. This policy is a minimum standard; your instructor may decide to augment this policy.

1. If the project is an individual effort project, you are not allowed to give code you have developed to another student or use code provided by another student. If the project is a group project, you are only allowed to share code with your group members.
2. You are encouraged to discuss programming projects with other students in the class, as long as the following rules are followed:
1. You view another student’s code only for the purpose of offering or receiving debugging assistance. Students can only give advice on what problems to look for; they cannot debug your code for you. All changes to your code must be made by you.
2. Your discussion is subject to the empty hands policy, which means you leave the discussion without any record (electronic, mechanical, or otherwise) of the discussion.
1. Any material from any outside source such as books, projects, and in particular, from the Web, should be properly referenced and should only be used if specifically allowed for the assignment.
2. To prevent unintended sharing, any code stored in a hosted repository (e.g., on GitHub) must be private. For group projects, your team members may, of course, be collaborators.
3. If you are aware of students violating this policy, you are encouraged to inform the professor of the course. Violating this policy will be treated as an academic misconduct for all students involved. See the Student Handbook for details on academic dishonesty.