IMPORTANT NOTE: Details in this schedule will change as the quarter progresses. In particular, student presentations will be added to the Detailed Schedule as they are assigned.

In general, there is a Reflective Journal Entry due every Monday. You will also research a historical or current language and provide an introductory presentation to your classmates at some point during the term. In addition there are several programming assignments or projects — Introduction to Scheme and Introduction to Haskell (Weeks 1 and 2), the Jay Interpreter (Weeks 5 - 7), N Queens (Weeks 8 and 9), and Introduction to Prolog (Week 10).

Note from Spring 2023: Would be good to have a video that shows how the JayInterpreter effects State changes as it executes the Jay intermediate program -- what do declarations do to the state? What do assignment statements do to the state? What do other statements do? I drew some pictures on the board in Spring 2023 (see posts in General channel of Teams site).


Note 2 from Spring 2023: I sent an email at the end of 8th week clarifying what is expected of reflections. Would have been good to be clearer about this earlier.
As you work on your reflection, please think about the purpose of it. The title of this course is “Principles of Programming Languages”, so you should be thinking about the principles you’re learning and how they apply to different languages. Some of you are doing a great job at this, but others are giving me either superficial summaries or lists of factoids. That’s not the goal. The goal is to do the reading, watch the videos, and REFLECT. What did you learn? How does that fit in with or expand what you knew, or thought you knew? Or maybe even turn what you knew on its head? A question from the final reflection at the end of the term, but which you could start thinking about now, is: How does what you are learning strengthen you as a computer scientist, and/or how do you think it will help you learn new languages in the future?
Note 3 from Spring 2023: Separate presentation reflections from "journal entries", and accept 2 reflection submissions (or have separate assignments) each week that includes presentations. (Why? I think reflections on presentations were better in 101 than 320, and this was part of the reason, I think.)
Old note: Could introduce 3 major paradigms up front and then have the presentations be strictly chronological (would show Prolog and Perl in the right timeframe, for example), but that would delay OO languages to be later than the topics come up in the book unless the earliest languages are earlier than in Spring 2022.
Consider re-doing Programming Assignment rubrics -- e.g., Jay Interpreter is worth 60 points. Not inline with our move to lower stakes grading.

This document was last modified on .

Reading assignments are from Sebesta unless specified otherwise.

Skip directly to Week 1 | Week 2 | Week 3 | Week 4 | Week 5 | Week 6 | Week 7 | Week 8 | Week 9 | Week 10

DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 1
Monday
(M1)
Create a Replit account or install Jupyter: (IDE for writing simple LISP exercises)
How to Use Replit – A Beginner's Guide from freeCodeCamp.
Install and Use Jupyter from Jupyter docs
Possibly still useful: Nick McCabe (K'20)'s 2016 notes on setting up Jupyter on Windows, Linux, or Macs.

Recommendation: Get Markdown Viewer extension for Chrome or Firefox: then go to Advanced Options, and turn on Markdown processing for files from https://www.cs.kzoo.edu and https://kit.cs.kzoo.edu.) (You might also want to install Visual Studio Code for editing Markdown files if you don't have it already, since it has a built-in Markdown previewer. You can use any editor, though, so long as it can handle plain-text fields.)
Welcome to Programming Languages!    (video for review — 6 min)

Topics:
Syllabus
Extra Goal (not mentioned in syllabus):
Understand the "inside jokes". For example, by the end of the quarter, you should know why James Iry's "A Brief, Incomplete, and Mostly Wrong History of Programmng Languages" is funny.
Note about Schedule and MLK Day

What languages/paradigms do we know?

Introduction to Programming Paradigms    (video for review — 20.5 min)
⇒ Why is our Teams icon a set of gears?
Wednesday
(W1)
Reading:
Read the first half of Chapter 1 (Sections 1.1-1.3, including all the subsections of 1.3). Use the Review Questions at the end of the chapter to check your understanding; the first 19 refer to this section of the chapter.)
Finish reading Chapter 1. Review Questions 20 - 30 at the end of the chapter refer to these pages.
Read and consider Problem Set questions 2 and 3 and be prepared to discuss them in class. (The Problem Set questions follow the Review Questions at the end of the chapter.)

Video — Paradigms:
God-Tier Developer Roadmap: Watch the first 6 minutes (or as much as you can take) of this 17-min video, a super-fast introduction to and comparison of a bunch of programming languages. (One of the comments refers to it as "Almost 17 minutes of condensed programming language slander and entertainment.") Stop when you start losing focus or interest — we'll come back to it at the end of the quarter, when it will make more sense (and you'll get some of the dry, understated jokes). (E.g. from 1:25: StackOverflow didn't exist until 2008.)

Videos — Functional Paradigm:
Introduction to Functional Languages - 6 min (slide)
Prefix, Infix, and Postfix Notation - 4 min (slide)

Presentations: Each of you will do at least one presentation on a programming language of historical or current interest. The Presentation Guide document is available online. The presentations will start Monday of 3rd Week. Please sign up for 3 possible presentations on the sign-up sheet in Teams → General → Files by Friday.
Topics:
Problem Set questions 2 and 3 from Chap. 1
Confirm: Everyone understands Infix, Prefix, Postfix Notations?

Functional Languages and Primitive Functions in Scheme
Lists as Recursive Data Structures (CAR, CDR, CONS)

Video for review:
Introduction to Primitive Functions in Scheme - 8 min
0:00 - 0:27: What is Scheme?
0:27 - 1:03: What is a REPL language?
1:03 - 8:04: Scheme demo in replit.com
1:03 - 3:02: Numbers and Strings
3:02 - 8:04: Lists: Car, Cdr, Cons
(6:31 - 6:45: In LISP, lists don't have to be homogenous)
(6:52 - 7:31: Functions as lists)

Time to talk to classmates about possible presentation topics

Friday
(F1)
Due Before Class:
List of at least 3 languages you would be willing to research and present.

Reading:
Chapter 15 starts in with first principles, covered in depth, and then gets more concrete. I prefer to start with general guidelines, then go to building-block ideas (primitive functions, atoms & lists, defining and using named functions), and then go to the more abstract (and less familiar) topic of lambda functions. So, you can read the first part of Chapter 15 (the intro through 15.5.8) straight through or, if you want an order closer to what we're doing in class, skip 15.2.2, 15.5.4, and 15.5.7, and come back to those after Wednesday's class. To assess your understanding of the reading, the first 8 Review Questions at the end of Chapter 15 correspond to this section of the chapter.

Video: Introduction to Functional Programming via Scheme (25 min) — functions that appear in video (Markdown file)
(You can probably go through the first 2 - 4 minutes at high speed, depending on how far you got in class on Friday.)
This could be edited to shorten!

Create a Replit account or install Jupyter if you haven't already. (See M1)
In-Class Activity — Introduction to Functional Programming in Scheme: Program the functions from the Preparation video — functions that appear in video (Markdown file)

Week 1 Reflective Journal Entry: (due Sunday evening)
Answer the questions in the Week 1 Journal Entry Markdown template
Looking ahead to Week 3, is Chap 4 similar to my Patterns & Guards video (which I currently have in M3)? Could Chap 4 and beginning of Chap 5 be W3 and current stuff in W3 move to F3? (Swap W3 and F3, basically.)
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 2
M2
Due Before Monday:
Week 1 Reflective Journal Entry (See F1 for description)
Wednesday.)
This could be edited to shorten!

Create a Replit account or install Jupyter if you haven't already. (See M1)
End of MLK = M2 exception -->
MLK Day - No Class
W2
Reading:
Read sections 15.2.2, 15.5.4, and 15.5.7, if you haven't already.
Read sections 15.5.9 through 15.5.12.

Video: Shifting Paradigms, Grinding Gears: Stack and Queue Examples - 17 min (I misspoke at the 16:00 mark: I should have said "... dequeue the thing that's at end of the rest of the list", not "the thing that's at the front of ...". I fixed this in the closed captions.) — Stack/Queue functions that appear in video (Markdown file)

Scheme Programming Assignment: (due Monday of 3rd Week)
Implement the functional exercises in the Functional Languages Exercises Assignment in Scheme. Use only the following basic functions: CAR, CDR, CONS, LIST, APPEND, IF, COND, the numeric predicate functions (<, >, =, etc), and the basic predicate functions (EQ?, EQV?, EQUAL?, LIST?, ATOM? and NULL?).
F2
Reading:
Read sections 15.5.13 - 15.5.14. Review Question 17 corresponds to these sections.

Video: Different types of Recursion - 15 min (slide, Fibonacci Animations (PowerPoint)) — This video uses a little bit of Haskell for a Fibonacci function, but don't get hung up on the syntax (which we'll see next week); it's the concepts that are important here.

Very Important Handout (thanks, as always, to xkcd.com)
Another Very Important Handout (xkcd.com)
Functional Programming: map

In-Class Activities:
Go over Scheme functions together in class, if necessary.

Very superficial introduction to some basic Haskell syntax.
FirstDemo.hs (expressions in the interpreter)
ClassExercises.hs (simple functions and test cases using the TestSuiteSupportModule)

Work with partner on planning/research for presentation.

Video for review:
Introduction to Haskell - Watch first 6.5 min; stop when I switch to slide about Types
This video needs to be edited! Transcript also not edited yet!

Week 2 Reflective Journal Entry: (due Sunday evening)
Answer the questions in the Week 2 Journal Entry Markdown template
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 3
M3
Due Before Monday:
Week 2 Reflective Journal Entry (See F2 for description)
Scheme Programming Assignment (See W2 for description)

Reading:
Read sections 15.7 - 15.9 of Sebesta (ML, Haskell, F#), paying particular attention to section 15.8 on Haskell.
In Learn You a Haskell, read:
Chapter 1, Introduction. Note that, although the author is using the ghc Haskell compiler/interpreter, everything covered in the book will work equally well in Replit.com, Haskell in Jupyter (if you have that installed), or other Haskell interpreters such as the Hugs interpreter.
Approximately the first 2/3rds of Chapter 2, Starting Out; stop when you get to Texas Ranges. (We'll come back to advanced list topics later.)
The first two sections of Chapter 3, Types and Typeclasses. Stop when you get to the section called "Typeclasses 101."
Note from 2018: Do further research into the difference between the type and data functions.

Videos:
Pattern Matching and Guards in Haskell - 12 min version; transcript is in progress... (or 17 min version, with good transcript) Sub-topics include: (time markings are for 12 min version)
1:30 - 3:40 Haskell signatures and brief intro to "currying"
3:50 inList1 (straight translation from Scheme)
4:35 Pattern Matching (like IF and COND)
6:20 Guards (like COND)
7:45 Naming components in pattern matching
10:00 Using '_' for unused parameters
Two Simple Examples - 4 min (These functions will be used in the video Wednesday on the TestSuiteSupportModule.)

Start Haskell Programming Assignment: (due Monday of 4th Week)
Implement the functional exercises in the Functional Languages Exercises Assignment in Haskell. Include thorough sets of test cases using the functions in the TestSuiteSupportModule. You may use this template Main module. You may use the ideas in the sample Haskell functions in the ClassExercises.hs module or any other Haskell functions or features.

W3
Videos:
TestSuiteSupportModule - 4 min (Watch the Two Simple Examples video from Monday if you haven't already.)
Static vs Dynamic Typing - 3.5 min
Basic Haskell Types - 4 min (slide)
Optional: Function Signatures: Declaring Function Parameter/Return types - 3 min. This is perhaps a bit clearer than the similar section in the Pattern Matching and Guards video. (slide)

Reading:
In Learn You a Haskell, read:
Read Chapter 4, Syntax in Functions. Note that the title of this chapter is misleading, since you already know something about the syntax for calling and defining functions. It could have been titled "Way Cool Features that Change the Way We Think About and Define Functions."
Read the beginning of Chapter 5 on Recursion, at least through the two definitions of maximum, so that you can see how pattern matching and recursion work together.
Recommended: Glance over the Haskell tutorial at www.haskell.org/tutorial so you have a sense of what is available from this resource.
Haskell Programming Assignment: (due Monday of 4th Week)
Continue from Monday
F3
Reading:
In Learn You a Haskell:
Chapter 2: Texas Ranges to the end (almost -- I recommend that you stop when you get to the "a2 + b2 = c2" triangle).
Chapter 3: Typeclasses 101 (this is the 3rd section)
Slide: Defining New Haskell Types (I haven't made a video for this topic)
An introduction to programming by Mary Rose Cook (an article about translating "imperative, unfunctional code ... to a functional style.")

Interesting (Optional) Video: Functional programming in JavaScript (30 min)

Very Important Handout (thanks, as always, to xkcd.com)
(To understand it 2 levels down: 1312: Haskell Explained)
(Usual) In-Class Activity:
Quick intro to syntax vs. semantics (next week we will go into more detail using C and Jay as examples)
Work with partner on planning/research for presentation.

Video for review:
The Meaning of Semantics - 3 min (slide)

Reflective Journal Entry: (due Sunday evening) (template for Week 3 (and later) using Markdown)
Things to include in your general reflection or as separate items afterward (your choice):
One of the differences between Scheme and Haskell is whether operators such as + and == are infix or prefix. Give an advantage of each.
Pick at least one other difference between these two functional languages to discuss using the language evaluation criteria introduced in Chapter 1 (readability, writeability, etc.).
What is lazy evaluation, and what is the connection to Haskell? (And why does that make the xkcd Very Important Handout even funnier?)

Assign Jay Interpreter project (due W7?) so that students can clone repo before Monday. (Don't forget to assign reflection too.)
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 4
M4
Due Before Monday:
Week 3 Reflective Journal Entry (See F3 for description)
Haskell Programming Assignment (See M3 or W3 for description)

Syntax: Lexical Analysis
Read Sections 3.1 - 3.2 in Sebesta.
Read Sections 4.1 - 4.2 in Sebesta. The first 7 review questions at the end of the chapter refer to these pages.
Regular Expressions: Very Important Handout (thanks, as always, to xkcd.com)

Introducing Jay
Clone the repository associated with the Jay Interpreter assignment in Kit.
Jay is a deliberately small, limited subset of C that we will use to explore language syntax and semantics in depth. Jay is defined in Tucker and Noonan"s Programming Languages: Principles and Paradigms. (selected pages are available as a PDF file in Kit)
Video: Introduction to Jay via an Example - 1.5 min (slide comes from. 43 of Tucker & Noonan)
Video: Lexical Syntax of Jay, including how it would be used by Lex - 5 min (lex file)
Associated reading: section 2.41 on p. 44 and Appendix section B.1 on p. 351 of Tucker & Noonan

Syntax: Grammars and Parsing
Read Sections 3.3 - 3.4 in Sebesta. The first 6 review questions at the end of the chapter refer to 3.1 - 3.3.1.
Look over Appendix A.13 and p. 53 from Kernighan and Ritchie's C Programming Language (K&R), Second Edition (these pages are available as a PDF file in Kit)

Jay's Grammar
Video: The Grammar for Jay including how it would be parsed by Yacc - 5 min
(yacc file, shorter version that shows grammar without compiler actions, super-short top-level view only)
Presentations for Week 4:
FORTRAN (1957, 1962)
COBOL (1959)
Algol (1958, 1960)
(other languages that would fit in this time frame include LISP (1958), BASIC (1964))

From High-Level Program Text to Running Code:
Compilation: Lexical analysis → Parsing → Code Generation
(file.c → token stream → parse tree → machine code)
Compilation to Execution: Compile → Link → Load
(*.c → *.o → a.out → memory)

What does a compiler do? What is an "intermediate representation"?

Go over the lex input that does lexical analysis for a subset of the Jay language.
What's missing? How would we add other operators, for example?

Small groups: If you were to extend Jay to create Kay, what would you want to add?
W4
Videos on Semantics, Part I:
Operational Semantics - 3 min (slide — click on "show details" to uncover the notes on Operational Semantics)
Denotational Semantics - 2.5 min (slide — click on 2nd "show details") This video refers to a "next video", which is the Representing State video for Monday; at one time it was the next one.
Looking Ahead: The Denotational Semantics of Jay - 1 min

Reading: Semantics
Read Section 3.5 in Sebesta up to (not including) 3.5.3.
Read Bob McCloskey's page on Loop Invariants (The sections on the Closed Curve Grid Game, Daisy Petal Game, and 2-Color Dutch National Flag Problem are optional, but do read the sections on Sum and Find Max about 3/4ths of the way down.)
Review Church-Turing Thesis from COMP 101/105/107 (or COMP 300). How is it relevant to this course?

Review creating new types & constructor functions in Haskell. (slide from F3 Defining New Haskell Types) — Preview of some of the reading for Friday

Generate a parse tree for the parts of the Fibonacci program not covered on p. 45 of Tucker & Noonan.

Looking Ahead: The Jay Interpreter will give you hands-on experience of denotational semantics (representing and manipulating state) and operational semantics (creating an interpreter that defines the semantics of Jay).
F4
Videos on Semantics, Part II:
Algebraic Axiom Semantics - 6.5 min (slide — click on 3rd "show details")
Axiomatic Semantics - 4.5 min (slide — click on 4th "show details")

Reading: Semantics
Read Section 3.5.3 in Sebesta. Everything from 3.5.3.4 (Sequences) on is optional.

Reading: Haskell Types
In Learn You a Haskell, read: Chapter 8, the first section (defining types in Haskell) and the section on Typeclasses 102. (This follows up on Typeclasses 101 in Chapter 3 (Types and Typeclasses) from Week 3.)
Supplemental Slide: Defining New Haskell Types

Video: Intermediate Representation for Jay - 4 min
Introduces an intermediate representation of our Jay program that corresponds to a parse tree, but represented in Haskell. (slide )

Presentations:
Watch the 15 seconds from 10:39-10:54 on APL in the God-Tier Developer Roadmap video. There's a language that looks different! If you're intrigued by APL and want to watch more, check out APL Wins (vs C++, Java & Python) (7.5 min).
Exercises Involving "Real-World" BNF Grammars
Appendix A.13 and p. 53 from K&R, Second Edition
Jay Grammar (incomplete)
(yacc input that parses a subset of the Jay grammar)

Reflective Journal Entry due Sunday evening: (template)
Things to include in your general reflection or as separate items afterward (your choice):
What are valid lexemes for identifiers in Java, Python, the language you are researching, and/or the languages presented this week (if that was covered)?
What is the difference between a recognizer and a generator? What is each useful for?
Does a compiler recognize and address syntax, semantics, or both? What does Rice's Theorem tell us about this? How does strong (static) vs weak type checking fit in?

Reflections on Student Presentations due Sunday evening: (template)
FORTRAN
COBOL (delayed — will be available later)
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 5
M5
Due Before Monday:
Week 4 Reflective Journal Entry (See F4 for description)
Reflections on Student Presentations (See F4 for description)

Sebesta: Variables and Binding
Read Sections 2.5 - 2.8 in Sebesta.
Read Sections 5.1 - 5.4 in Sebesta.

Intro to the Imperative/Procedural Paradigm:
Imperative Paradigm & State (slide that supplements reading in Chapter 5, no video)
(Memory, Environment, Variables, Binding)

Maybe these 2 videos could be replaced by a single, shorter, more straight-forward video.
Representing State (Variables) in Jay:
Video: Representing State, Representing State in Jay, and Understanding a Jay Program as a series of State changes - 10 min (slide, Haskell version of Jay intermediate representation with extra comments
Video: What Types Do We Need to Represent Jay’s State in Haskell? - 16 min — You may need to turn up the brightness to see the green writing on my "grayboard". (The video quality is not as good as some other videos.)
(same ideas in narrative or "transcript" form: Intro to Values and State text file (JayValueStateIntro.txt).)

Jay Interpreter Programming Assignment:
Jay Interpreter Project — Part 1: Representing State
This web page has instructions for whole project; you will develop and submit the Jay Interpreter Project in stages.
Start by cloning the JayInterpreter repository from Kit and then copying in the TestSuiteSupportModule which you used for the earlier Haskell exercises.
W5
Due Before Class:
Jay Interpreter Programming Assignment, Part 1

Sebesta: Scope
Read the rest of Chapter 5 in Sebesta.
Read Section 2.9 in Sebesta.

External Video: Scope
Watch this video from The Coding Train - 12 min. Note that "function scope" does not have to do with functional languages, nor is it related to dynamic scope. So, what are the differences between dynamic scope, lexical scope, block scope, and function scope?
Scope in Haskell: Module statement in ValuesAndState.hs and JayDecls.hs (and JayExpressions.hs, etc.)

Jay Interpreter Programming Assignment:
Part 2: Implementing Declarations

Could teach about map function and simplify addToState and addDecl, but might need to reorder all the tests again because of order of variables in State.
F5
Presentations: Ars Technica article on the history and design decisions behind C

Optional: Watch C in 100 Seconds as a quick, slightly light-hearted review. (Read some of the comments for some more light-hearted information.)

Optional: If you are still working on the first three functions for the Jay Interpreter (addToState, bind, and deref), you might want to watch me program them in this video.
Discussion: What type of scope does Jay support? How would our representation of State have to change if we extended Jay to support functions other than main or to support block scope?

Reflective Journal Entry due Sunday evening: (template)
Things to include in your general reflection or as separate items afterward (your choice): Talk about Memory, Environment, Variables, and Binding in relation to the reading for this week, the languages you discuss, and the Jay Interpreter. How do they compare?

Reflections on Student Presentations due Sunday evening: (template)
COBOL (if available yet)
Algol
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 6
M6
Due Before Monday:
Week 5 Reflective Journal Entry (See F5 for description)
Reflections on Student Presentations (See F5 for description)

Due Before Class:
Jay Interpreter Programming Assignment, Part 2

Reading: Data Types
Read Chapter 6 in Sebesta.
C Types (slide, no video)
(including C struct and union, and general idea of declarations vs. definitions)
Java should have been after Python, at least chronologically. (Did I put Python later because it is multi-paradigm? And Ruby is a reaction to Python.)
Dangling Pointers, Memory Leaks: Very Important Handout, Another Very Important Handout (thanks, as always, to xkcd.com)
Presentations for Week 6:
SNOBOL (1962) or awk (1977)
Perl (1987)
R (1993)
(other unusual or niche languages include Prolog(1972), awk (1977), Perl (1987))

Discussion: Dangling pointers, memory leaks, garbage collection

Haskell: Filter

Discussion (Originally F5): What type of scope does Jay support? How would our representation of State have to change if we extended Jay to support functions other than main or to support block scope?
W6
Video:
Expressions vs. Statements - 13 min (slide)
First 10 min: Distinction between Expressions and Statements (in most languages)
10:17 - end: How does C break the rules?

Reading: Expressions and Assignments
Read Chapter 7 in Sebesta.
Read Sections 2.11 - 2.12 in Sebesta.
Confirm: Everyone understands Expressions vs. Statements?

Haskell Tip:
removeAtomOrList :: Eq a => a -> [a] -> [a]

Jay Interpreter Programming Assignment:
Part 3: Implementing Expressions
F6
Due Before Class:
Jay Interpreter Programming Assignment, Part 3

Reading: Statements
Read Sections 8.1 and 8.2 in Sebesta.
Read Section 2.14 in Sebesta.
Topics to pay particular attention to or think about:
Else ambiguity
C-style switch vs. Haskell guards (e.g., legal types for cases vs. guards)

GoTo this Very Important Handout (thanks, as always, to xkcd.com)

Discussion:
Else ambiguity
C-style switch vs. Haskell guards (e.g., legal types for cases vs. guards)
Surprises?

Jay Interpreter Programming Assignment:
Part 4: Implementing Statements & Completing the Interpreter

Maybe we need a week off from Reflective Journal entries? We did in 2020.
Reflective Journal Entry: No Journal entry this week!
Reflections on Student Presentations due Sunday evening: (template)
Simula
Smalltalk
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 7
M7
Due Before Monday:
No Journal entry due this week! Work on Jay Interpreter assignment instead.
Reflections on Student Presentations (See F6 for description)

Reading: Statements (continued), Subprograms
Read the rest of Chapter 8 in Sebesta.
Read Sections 9.1, 9.2 in Sebesta.

Should this be Sections 9.1 - 9.4 ?
Presentations for Week 7:
Python (1991)
PHP (1995)
(other languages that would fit in this timeframe include Haskell, Java, Ruby, JavaScript)

Jay Interpreter Programming Assignment:
Complete Jay Interpreter
W7
Due Before Wednesday:
Jay Interpreter Programming Assignment (complete; push to Kit)

Reading: Subprograms (continued)
Read Section 9.3 - 9.5 in Sebesta.

Should this be Sections 9.3 - 9.5 ?
Parameter-passing: pass-by-value, pass-by-reference, pass-by-value-result, pass-by-name
F7
Reading: Subprograms (continued)
Read the rest of Chapter 9 in Sebesta.
In-class activity: Jay Follow-up Activity

Reflective Journal Entry due Sunday evening (template)
Things to include in your general reflection or as separate items afterward (your choice):
Talk about your experience with the Jay Interpreter and its relationship to the topics from Weeks 6 and 7.
Don't forget to talk about the languages from last week as well as the languages from this week

Reflections on Student Presentations due Sunday evening: (template)
JavaScript
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 8
M8
Due Before Monday:
Week 7 Reflective Journal Entry (See F7 for description)
Reflections on Student Presentations (See F7 for description)

Reading: Implementing Subprograms
Read Chapter 10 in Sebesta.

Presentations for Week 8:
Rust (available beginning of Week 8)
Scratch (available beginning of Week 8)
Scala (available beginning of Week 8)
Prolog (available by end of Week 8)
Presentations for Week 8:
Objective-C (1983)
C++ (1983)
Eiffel (1986)

Read through and compare all of the early attempts at making a board and accessing its elements:
First attempt
Second attempt
Third attempt
Fourth attempt
Fifth attempt

N Queens Programming Project
W8
Reading: Data Abstraction and Encapsulation
Read Chapter 11 in Sebesta.
Read Section 2.10 in Sebesta.
N Queens Programming Project
F8
Reading: Object-Oriented Languages
Read Chapter 12 in Sebesta.
Read Sections 2.15, 2.16, 2.17, and 2.19 in Sebesta.

Analysis Questions to Mull Over
Of the issues we have discussed in Chapters 5 - 9, 11 - 12 and 14, which are relevant to Haskell, and how does it handle those issues?
Of the issues we have discussed in Chapters 5 - 9, 11 - 12 and 14, which are relevant to the language on which you did a presentation, and how does it handle those issues?
N Queens Programming Project

Reflective Journal Entry due Sunday evening (template)
Things to include in your general reflection or as separate items afterward (your choice):
Pick one topic from Chapters 5 - 10 of our textbook and discuss what it would mean to add it to Jay. You don't have to add it (unless you want to!), but think/write about what it would take to do so. Some examples are listed in the Jay Follow-up document.

Reflections on Student Presentations due Sunday evening: (template)
Rust (beginning of Week 8)
Scratch (beginning of Week 8)
Scala (beginning of Week 8)
Prolog (end of Week 8)
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 9
M9
Due Before Monday:
Week 8 Reflective Journal Entry (See F8 for description)
Reflections on Student Presentations (See F8 for description)

Reading:
How Rust went from a side project to the world’s most-loved programming language
Presentations for Week 9:
Go (2009)
Rust (2010)
Swift (2014)

Discussion on abstraction in programming languages and in software development.

One of the themes in the history of programming languages is a movement to more and more abstraction. We have the development of more sophisticated types, abstraction through functions with parameters, parameterized data types (e.g., ArrayList of X), etc. Object-oriented programming was another level of abstraction, allowing us to encapsulate data and functions on the data together.

N Queens Programming Project
W9
Reading: Prolog and Logic Programming Languages
Read Sections 16.1 - 16.6 in Sebesta.
Read Section 2.13 in Sebesta.
Start Prolog Programming Assignment: Do one of the following alternatives:
Alternative 1: Do Problem Set Exercises 3 and 4 at the end of Chapter 16. Please remember, though, that this is a Prolog exercise and not a true geneology exercise, so if one of your parents was one of 10 kids, for example, you could conveniently forget approx. 7 - 8 of your aunts and uncles without my being any the wiser and without losing anything substantive from the exercise. The instruction to "Be sure to include all relationships" refers to relationships (e.g., grandparent, parent, sibling, aunt, cousin, niece, etc.), not relations (e.g., 4 siblings, 5 aunts, 8 cousins, etc.) Also, if you read the instructions absolutely literally, you need not include step-family or in-laws unless you want to.
Programming Alternative: If you prefer, and if you are able to get and install a Prolog environment on your own machine, you may choose to do Programming Project Exercises 1 - 7 at the end of Chapter 16 instead of the Problem Set exercises.

F9
Due Before Class:
N Queens Programming Project

Reading: Prolog continued
Read the rest of Chapter 16 in Sebesta.
Quiz (at least that's what we did in 2018; probably a terminology quiz, but content is To Be Announced)
2023: Review terminology from this term as if there were going to be a quiz — it will be good preparation for your final reflection next week.

Reflective Journal Entry: No Journal entry this week!

Reflections on Student Presentations due Sunday evening: (template)
R
DAY PREPARATION IN-CLASS TOPIC/ACTIVITY
Week 10
M10
Due Before Monday:
No Journal entry due this week!
Reflections on Student Presentations (See F9 for description)

Reading: (Exception Handling)
Read Chapter 14 in Sebesta.
Good article for Spring 2018: Programmable Programming Languages (from CACM); Could compare to a recent article on Grace, for example.
Video:
God-Tier Developer Roadmap: This 17-min video is a super-fast introduction to, or comparison of, approx. 50 programming languages. (One of the comments refers to it as "Almost 17 minutes of condensed programming language slander and entertainment.") How much more do you understand now than you could at the beginning of the quarter? Did you notice the dry, understated jokes?
In-class work on Problem Set #9
F10
W10
Reading: (Concurrency)
Read Chapter 13 in Sebesta.

Presentations: In the absence of a presentation, watch the hour-long The Worst Programming Language Ever by Mark Rendle
"There's something good you can say about every programming language. But that's no fun. Instead, let's take the worst features of all the languages we know, and put them together to create an abomination with the worst syntax, the worst semantics, the worst foot-guns and the worst runtime."
In-class group activity: Design your own worst language!

Final Reflective Journal Entry: (due Monday of Exam Week)
In your final Growth Journal entry, you should reflect on the quarter as a whole (not just 10th Week).
One way of looking at this might be:
Over the course of your career, you are likely to pick up a number of new languages, including scripting languages, special-purpose languages for interacting with specific software tools, new languages that haven't been dreamt of yet, and maybe even old languages to understand and update legacy code. Looking back at the concepts and specific languages that you have learned this quarter, and looking back at your weekly reflections, what have you learned that will help you pick up new languages in the future?
W10
F10
Due Before Wednesday:
Prolog Assignment

Reading: (Scripting Languages)
Read Sections 2.18 and 2.20 in Sebesta.

Presentation: In the absence of a presentation, watch Object Oriented Programming vs Functional Programming (19 min). This video talks about paradigms in general, and ends by briefly talking about a programming style to support concurrent programming.
To be announced
2023: No class
Exam Week There is no final exam in this class. The Final Reflective Journal Entry is due 5 pm on Monday of Exam Week with NO EXCEPTIONS OR EXTENSIONS.