Skip to main content

Yet another rebuild of the CSC-151 repository (#1179)

Topics/tags: CSC-151

Happy New Year!

Yes, I realize that my good wishes for the new year are a few days late, but better late than never, as some folks say.

Today I transitioned from the break part of winter break to the work part of winter break. I’m not exactly sure when the break part started, since I had grades due on December 28. But there were certainly a bunch of days between December 23rd and now in which I did not think about work and I spent time with family.

And it remains a break. I won’t be teaching. I won’t be going to many meetings, unless we count the workshops I signed up for next week as meetings. But I should be working to get ready for the new semester.

During last semester, I set up a checklist of changes I wanted to make to CSC-151 and the CSC-151 Web site. It is, as always, incomplete. But it’s also wide ranging, from steps to make assignments less stressful to students to changes to underlying code. I think I even have a few notes about musings to write. You can find the checklist as an appendix to the musing.

Although it’s not clear from the checklist, my first step (after writing the checklist) was to break the repository for the course Web site into what I thought would be two separate repositories. It ended up being three repositories.

Why? That is, why did I want to break up the repository?

First of all, the repository seems to have gathered a bunch of cruft, old readings or code files we no longer use, materials only appropriate to other versions of the course, person-specific handouts [1], the too-many new materials we had to develop when we went online and switched to terms, old quizzes and exams that are no longer relevant now that we’ve switched to mastery grading. You know. Cruft. [2]

Second, the repository has grown to include both materials that should be public, such as the assignments and labs, and materials that should be private, such as autograders and learning assessments. I’m not quite sure how they ended up in the same repository.

The second issue suggests why I wanted two repositories: one for the public Web site, one for the private administrative materials. The first issue suggests that I need a more careful process than just dump it all in and work from there.

I created the two repositories a week or so ago. Today, I started putting them together. Well, I may have drafted the schedule a week or so ago, as I was taking a break from grading. And I did other stuff today, such as work on the autograders.

Speaking of the autograder, the autograder libraries ended up being the third project. I’m not sure whether anyone other than me (and the other CSC-151 folks) will use them, but there’s no reason not to make them public.

Now I’m working on the first issue: Figuring out what I have to move from the old repository into the new repositories. Or perhaps I should say issues, plural, as I’m also trying to update/revise things as I move them.

As always, I find myself asking myself, Why?, as in Why did I decide to undertake this time-consuming project?

Still, I think it’s worth it. If the source for the course Web site is public, others can pull from it, post comments, and more. Organizing materials is always worthwhile, right? And I need to spend more time with the CSC-151 materials as I prepare to teach three sections in the spring and to pass it on to someone else for next year.

Plus, I get to write code, think about teaching, and more.

Next up: Moving over 53 (!!) readings and 31 labs, making minor adjustments to some and major adjustments to others. Also, writing a few more readings. And I mustn’t forget the assignments.

Or maybe I should move the to-do list to the issues lists on each repo.

Or play with the new autograder library.

Or ….

In any case, it should be a fun break. And all this work will be good preparation for next year’s project to revive the old image-based 151.


I suppose I should also muse a bit during break. I wonder how many musings will be related to CSC-151.

Appendix: Repositories

The repository for the course Web site can be found at

The site (under development) can be found at

The repository for the autograder libraries can be found at

For those of you with the right privileges, the repository for the CSC-151 administrative materials can be found at

Appendix: Sam’s sketchy checklist

Here’s the checklist I put together for updating 151 this semester. It is, as I said, incomplete. I’m also moving many of the parts to the various Github repositories I use for the course. At some point through writing the checklist, I started to break things out into sections, but that re-organization is imperfect.

I’ve checked off a few of the things that I’ve done.

[ ] Add the S&B archives back in.  I'll need to see what I did before.
[ ] Review the assignments from the first version of the course.
[x] Make searching and sorting as different LAs.
[x] Maybe a refactoring LA.  (That does end up in style.)
[ ] Figure out how to have multiple sets of notes/eboards.
[x] Create separate repositories for the public materials and the
    private materials.  (Hopefully, we'll do some cleanup along
    the way.)
[x] Figure out what to cut from the curriculum for the new "Working
    Differently Days".
[ ] Get rid of the damn "go".
[ ] Write "An Instructor's Guide to CSC-151"
[ ] Work on saving to file for tests.
[ ] Teach the two-parameter `substring`.
[ ] Teach `remove*`.
[ ] When we do files, teach about saving Racket code to files (which
    can be useful for, say, the Jane Eyre syllax).  Or maybe just have
    a value->file, file->value, values->file, and file->values and
    document those.  (values->file should write one per line, rather
    than write a list)
[ ] Make it clear to students that they should indicate *how* people
    helped them.  Not "Lindsey Smith helped me" but "Lindsey Smith
    helped me with _these procedures_."
[ ] Rewrite `file->words`.
[ ] Update file procedures so that you can track them.  `(file-notes-on)`
[ ] Update the hash table reading with the three-parameter `hash-ref`.
[ ] Rewrite the whole XML stuff in a new order.
    * Representing XML (Day one)
    * Recursive processing (using `match`) (Day two)
    * Transforming (Day three)
    * SXML and SXPATH processes


[x] Cite the damn source!
[ ] A grader's guide to CCS-151.
[ ] An instructor's guide to CSC-151.

Teach Testing

[ ] Drop instructions on test suites.
[ ] Make sure we always use `test-xxx` rather than `check-xxx`.

Grader Instructions

[ ] Style checklist.
    [ ] Blank lines between procedures
    [ ] Reindented with Ctrl-I
    [ ] Avoid too-long lines
    [ ] Parameters either on same line or multiple lines
    [ ] Spelling
    [ ] Avoid repeated code and repeated calculations
    [ ] Avoid using length to determine if a list has one element (or
        two or ...)
    [ ] Avoid using `append`
[ ] Leave notes in the code!
[ ] Put a checklist in the comments (it helps the students and us).
    Don't just refer to the rubric and code comments.


[x] See if I can preconfigure a Docker for the graders. 
    (Tried, but it doesn't work well.)
[ ] Work on autograders so that they provide more of the grading.
[ ] Rebuild the autograders to use the latest version of the library.
[ ] Work on how the tests are reported.
[ ] Check on ways to give zero for autograder results.
[x] Separate my reports from the students in the autograder (e.g. by
    putting a special character in front).
[ ] Consider having the autograder report on levels (R, M, E tests).
    For example, working with a partial syllax on MP5 is an E issue.


[ ] Consider starter code for early MPs. [ ] Cut back on work in MPs. At least the later MPs. (MPs 5, 6, 7). [ ] Update rubrics for human graders (per problem, rather than per grade). [ ] Consider grader notes for each assignment. (Those will go in the admin repository.)


[ ] More tests.  In particular, add `(valid-isbn? "123456780X")`, which
    should be false.  (Checking all ending digits would be good.)
[ ] Teach them about libraries. `(require "string-utils.rkt")`

Dale-Chall MP3

[ ] Consider adding a thought question on the more efficient version of 
    easy-word?  (Maybe three versions.  lambda/let, let/lambda, and
    the complex one.)
[ ] Update the Dale-Chall MP to more clearly separate work (e.g.,
    count in list).  Bonus for a procedure that uses rexes to count
    in a string?
[ ] Give them a procedure to read from the positive words and negative
    words files.  (Or have them write one.)  "Reading word lists."  I
    could use a list of Grinnell words as an example.
[ ] Write a real autograder.
[ ] Explain percentages.
[ ] For E, notion of word should be consistent.
[ ] Tests!  Perhaps making files.
[ ] Consider some grader notes (e.g., things to look for).
    [ ] In score->grade, repeated testing (e.g., (< score 5.0) followed by 
        (>= score 5.0))..
    [ ] In score->grade, missing ranges (e.g., <= 4.9 followed by >= 5.0.)
    [ ] `dale-chall-score` should call `compute-dale-chall-score` (it's
        a decomposition issue)
[ ] Give them a mechanism for checking how many times they read from a
    file (e.g., `file2string` and `file2words` and ....).

Freestyle MP4

[ ] Add examples.
[ ] Make it clear that the image needs to show a comparison of two
    texts (the examples should do that).
[ ] Make it clear that the image should change (not just select
    between a few images)
[ ] Use a standard procedure name.
[ ] Give them a sample visualization procedure, which they can change.

Text Generation MP5

[ ] Break up the Mad Libs a bit more.  For example, there should be
    a `replace-character`.
[ ] Move the "don't crash on empty input" to "required for E" (tests
    will need to identify that).
[ ] Drop rhyming.
[ ] Give them remove*?

Statistical Language Generation MP6

[ ] Check the autograder on hash tables.  (Johnny Bachman's second
    redo is a good example.)
[ ] Clarify steps more.
[ ] Provide the probabilistic select.

[1] Admittedly, those are mostly mine.

[2] Or maybe you don’t know. Or maybe I’m using the term inappropriately.

Version 1.0 of 2022-01-03.