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).
FINDING READING ASSIGNMENTS: Some reading assignments are available in the Course Files section of Kit. Amir Kamil's Programming Language Principles and Paradigms is available online and Kent Lee's Foundations of Programming Languages, 2nd Ed. is available in e-book form though the library. Several versions of Learn You a Haskell for Great Good! are available online, including:
SPECIFIC NOTE FOR WINTER 2026: We will be moving from using Sebesta's textbook as a required text to new options this term. This schedule still includes the reading assignments from Sebesta (specifically, the 11th edition). The reading assignments will definitely change as the term progresses!
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?
This document was last modified on .
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.)
|
Topics:
Syllabus
Extra Goal (not mentioned in syllabus):
Understand the "inside jokes". For example, by the end
of the term, you should know why James
Iry's "A Brief, Incomplete, and Mostly Wrong History
of Programmng Languages" is funny.
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 selected pages from Sebesta's
Concepts of Programming Languages specified in
Kit (Section 1.1 and Section 1.3).
Video —
Some History:
Watch 2 minutes (9:45 - 11:48) of
God-Tier Developer Roadmap by
Fireship, that zips through some important history of
programming languages.
(The full 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." We'll come back to it at the end of the
term.)
Videos —
Setting the Stage for the Functional Paradigm:
(Prefix, Infix, and Postfix Notation
- 4 min
(Expressions vs. Statements -
6.5 min
(slide)
First 6.5 min: Expressions vs. Statements in
most languages
(You can watch the whole thing, but we will
return to the second half later.)
|
Topics:
Discussion Questions to confirm: Everyone understands
Infix, Prefix, Postfix Notations? Everyone understands
Expressions vs. Statements?
Introduction to Functional Languages
(slide)
(video for review - 6 min)
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.
Alternative: have students sign up
in class on Wed and/or Fri.
|
| Friday (F1) |
Due Before Class:
List of at least 3 languages you would be willing to research and present. Reading:
Read sections 1.4, 1.4.1, and 1.4.2 on Compilation and
Interpretation in Lee's
Foundations of Programming
Languages, 2nd Ed..
Videos:
Review
Introduction to Functional Languages
- 6 min
(slide)
Demo: First Scheme Experiments
- 8 min
|
Topics:
Review Key Concepts of Functional Languages
(slide)
Lists as Recursive Data Structures (CAR, CDR, CONS)
Start experimenting with Scheme
yourself!
Recommendation: use https://try.scheme.org/.
Note: the last set of examples are from the
Intro to Functional Programming
via Scheme
video for Monday, so you may want to watch that
before doing the last set.
Mention Jupyter, JDoodle, etc?
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 Sunday Evening:
Week 1
Reflective Journal Entry (See F1 for description)
Reading:
Read Chapter 8 Introduction to Scheme (pp. 66-72) in Kamil's
Programming Language Principles and
Paradigms.
Video:
Intro to Functional Programming via
Scheme (25 min)
—
functions that appear in video
(You may be able to go through the
beginning at high speed, depending on how
far you got in class on Friday. Note that I was
using
replit.com, which has the
interpreter on the right and the file editor on the
left, instead of the other way around like
try.scheme.org.)
This could be edited to
shorten!
Discussion Questions:
|
In-Class Activities
Complete experiments from
Friday's in-class activity.
Recommendation: use
https://try.scheme.org/.
Start the
Scheme Language Exercises Assignment.
(due Friday of 2nd Week)
Scheme Test Suite Module?
Exercises/SchemeTestSuiteExample.scm
|
| W2 |
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 the 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
There's also a 3:45 min GrindingGearsIntro version
of this -- should I share this here instead?
Very Important Handout
(xkcd.com)
Another
Very Important Handout
(thanks, as always, to xkcd.com)
|
Functional
Programming: map
In-Class Activities
Scheme Language Exercises Assignment.
(due Friday of 2nd Week)
Is there a Scheme Unit Test application we should tell
students about? Or use
Exercises/SchemeTestSuiteExample.scm ?
|
| F2 |
Due on Kit:
Reading:
Read Chapter 10 (pp. 81-85) on Recursion in
Kamil.
Read Section 12.1 on Lambda Functions in Scheme
(pp. 94-95) in
Kamil.
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.
|
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 on presentation planning/research.
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 Sunday (by 11:59
p.m.):
Week 2 Reflective Journal Entry (See F2 for description)
|
MLK DAY - NO CLASS
|
| W3 |
Accessing Haskell:
Install
ghci
from Haskell.org (and the Haskell VS Code
extension if you want), or find and choose a
different Haskell interpreter, e.g., JDoodle, Jupyter,
or replit.com.
Reading:
Read section 15.8 from Sebesta's
Concepts of Programming Languages (in Kit).
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 other Haskell
interpreters.
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 (one using
pattern matching; one using a guarded condition) - 4 min
TestSuiteSupportModule - 4 min
(the code)
|
Start Haskell Language
Exercises Assignment:
(due Monday of 4th Week)
Implement the functional exercises in the Scheme
Language 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.
|
| F3 |
Reading
(Should have been assigned F2):
Read Section 12.1 on Lambda Functions in Scheme
(pp. 94-95) in
Kamil.
Videos:
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
two-minute 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.
|
Presentations for Week
3:
(Videos or slides in the Presentations channel on Teams)
FORTRAN (1957, 1962)
LISP (1958)
Reflections due by Tuesdays at midnight.
(Presentation reflection
template.) This file may also be found in the Files
folder of the Presentations channel in Teams.)
In-Class Activity:
Discussion on defining types in
Haskell
Work on in-progress activities as time permits.
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?)
Presentation
Reflections for Week 3 (due Tuesday): FORTRAN, LISP
(template)
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
| M4 |
Due Sunday Evening:
Week 3
Reflective Journal Entry (See F3 for description)
Due Monday on Kit:
Haskell
Language Exercises Assignment (See W3 for
description)
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)
Chapter 8, the first section (defining types in
Haskell) and the section on Typeclasses 102.
Supplemental Slide:
Defining New Haskell Types
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) |
In-Class Activities:
From High-Level Program Text to Running Code:
Compilation to Execution: Compile
→ Link → Load
(*.c → *.o → a.out → memory)
Compilation: Lexical analysis
→ Parsing → Code Generation
(file.c → token stream → parse tree → machine code) What does a compiler do? What is an
"intermediate representation"?
Introduction to Jay via an Example
Video for review: - 1.5 min (slide comes from p. 43 of Tucker & Noonan)
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)
Assign Jay Interpreter project (due W7?) so that students can clone repo before Monday. (Don't forget to assign reflection too.) |
| W4 |
Reading —
Syntax: Lexical Analysis
Read Section 3.1 on Lexical Structure, Syntax, and
Semantics (pp. 12-13) in
Kamil.
(He makes occasional references to C++
because his students are familiar with it, but most of
those references are true of C and Java also.)
Read the intro to Ch. 2 and section 2.1 (pp. 31-33) in Lee.
Read Section 7.1 on Regular Expressions
(pp. 55-57) in
Kamil.
Regular
Expressions:
Very Important Handout
(thanks, as always, to xkcd.com)
Reading —
Syntax: Grammars and Parsing
Read sections 2.2-2.5 (pp. 33-38) in Lee.
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.)
Reading —
Introducing Jay
Read p. 43, section 2.4.1 on p. 44, and
Appendix section B.1 on p. 351 of Tucker & Noonan
(available on Kit)
If you haven't already, clone the repository associated
with the Jay Interpreter assignment in Kit.
|
The Grammar for Jay, including how it would be parsed
by Yacc
Video for review - 5 min
Small groups: If you were to extend Jay to create Kay,
what would you want to add?
|
| F4 |
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 Friday ; at one time
it was the next one.
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.)
|
Presentations for Week
4:
(Videos or slides in the Presentations channel on Teams)
COBOL (1959)
Algol (1958, 1960)
Review Church-Turing Thesis from COMP 101 (or COMP
300). How is it relevant to this course?
Review creating new types & constructor functions in
Haskell.
(slide)
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).
Presentation
Reflections for Week 4 (due Tuesday): COBOL, Algol
(template)
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
| M5 |
Due Sunday Evening:
Week 4
Reflective Journal Entry (See Friday for description)
Due Before Wednesday:
Week 4
Presentation Reflections (See W4 for template)
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.
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:
Interesing video on progression of programming
languages! Check out 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
|
| F5 |
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.
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 so far (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?
Presentation
Reflections for Week 5 (due Tuesday): COBOL, Algol
(template)
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
| M6 |
Due Sunday Evening:
Week 5
Reflective Journal Entry (See F5 for description)
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:
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. |
| W6 |
Due Before Class:
Reflections on Week 5 Student
Presentations due by midnight Tuesday.
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 - 9:40 min.
|
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?
Presentations for
Week 6:
(Videos in the Presentations channel on
Teams) (Reflections due by Tuesday at midnight.
Reflection
template. )
C++
Smalltalk
Reflective Journal
Entry due Sunday evening: No reflection due this week!
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
|
Week 7
M7 |
Due Sunday Evening:
No Reflective Journal Entry due this week
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)
|
Discussion:
Dangling pointers, memory leaks, garbage collection
Haskell:
Filter
Discussion (Follow-up from W6):
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?
Jay Interpreter
Programming Assignment:
Start working on
Part 3: Implementing
Expressions
|
| W7 |
Due Before Wednesday:
Reflections on Student
Presentations (See W6 for description)
Video:
Expressions vs. Statements - 13 min
(slide)
First 6.5 min: Distinction between Expressions and
Statements in most languages (review)
6:29 - 7:22: LHS semantics
7:23 - 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:
Presentations for
Week 7:
Smalltalk
|
| F7 |
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:
Maybe we need a week off from Reflective Journal entries?
We did in 2020.
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, Binding, and Expressions
in relation to the recent readings, the languages
you discuss, and the Jay Interpreter. How do they
compare?
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
|
Week 8
M8 |
Due Sunday Evening:
Week 7 Reflective Journal Entry (See F7 for description)
Reflections on Student
Presentations due by midnight Tuesday (See W7 for description)
Reading:
Statements
Read Sections 8.1 - 8.3 in Sebesta.
Should this be Sections 9.1 - 9.4 ? |
Jay Interpreter
Programming Assignment:
|
| W8 |
Due Before Wednesay:
Reflections on Student
Presentations (See W7 for description)
Reading: Statements (continued), Subprograms
Read the rest of Chapter 8 and Sections 9.1 - 9.3 in Sebesta.
Should this be Sections 9.3 - 9.5 ? |
Discussion on statements, subprograms
Parameter-passing: (Maybe Friday?)
pass-by-value, pass-by-reference,
pass-by-value-result, pass-by-name
Presentations:
Look in the Presentations channel of the class
Teams site for the presentations on R, Rust, and Prolog.
|
| F8 |
Due Today:
Jay Interpreter
Programming Assignment (complete; push to Kit)
Reading: Subprograms
(continued)
Read Sections 9.4 - 9.8 in Sebesta.
|
In-class activity: Jay Follow-up Activity (Postponed to M9)
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, 7, and 8.
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
|
Week 9
M9 |
Due Sunday Evening:
Week 8
Reflective Journal Entry (See F8 for description)
Reading:
Implementing Subprograms
Read Chapter 10 in Sebesta.
|
In-class activity: Jay Follow-up Activity (From F9)
Read through and compare all of the early attempts at
making a board and accessing its elements:
|
| W9 |
Due Before Wednesay:
Reflections on Student
Presentations (See W8 for description)
Reading:
Implementing Subprograms
Finish reading Chapter 10 in Sebesta.
|
In-class Activity: Discuss any review questions from Chapter 10 that students want, work on Problem Set exercises 2, 3 (to be submitted)
Presentations:
Look in the Presentations channel of the class
Teams site for the presentations on Go, PHP, and Eiffel.
|
| F9 |
Reading:
Data Abstraction and Encapsulation
Read Chapter 11 in Sebesta.
Read Section 2.10 in Sebesta.
|
Discussion:
ADTs, Encapsulation
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.
|
| DAY | PREPARATION | IN-CLASS TOPIC/ACTIVITY |
|
Week 10
M10 |
Due Sunday Evening:
Week 9
Reflective Journal Entry (See F9 for description)
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?
|
Discussion on abstraction in programming languages and in software development.
|
| W10 |
Due Before Wednesday:
Reflections on Student
Presentations (See W9 for description)
Optional Reading:
Prolog and Logic Programming Languages
Read Sections 16.1 - 16.6 in Sebesta (more detailed).
Read Section 2.13 in Sebesta (a brief introduction).
Presentation: Watch the presentation on Prolog in the Presentations channel of our Team site.
Reading:
Article from MIT Technology Review:
How Rust went from a side project to
the world’s most-loved programming language (If you do not have access to the article online, you can find it in the Files folder of the General channel on our Teams site)
|
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.
Alternative 2 (Programming): If you prefer, you may choose to do Programming Project Exercises
1 - 7 at the end of Chapter 16 instead of the Problem Set
exercises or find examples online of programs for problems such as map-coloring or N-Queens to explore with coding. You may try using the SWISH Prolog compiler.
(Some possibilities: Prolog examples, Prolog examples)
|
| F10 |
Due Friday:
Prolog
Assignment
NQueens Project Reading:
(Scripting Languages)
Read Sections 2.18 and 2.20 in Sebesta.
Some Videos to finish the term:
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 term? Did you notice the dry,
understated jokes?
(E.g. from 1:25: StackOverflow didn't exist until 2008.)
0:55 - 2:06 Scratch, Basic, Python, JS
2:20 - 3:05 Bash, HTML/CSS, SQL
3:05 - 3:40 Dynamic Type HLL: PHP, Lua, Ruby, R, Julia
3:46 - 4:30 Static-Typed HLL: Java, C#, Typescript
4:30 - 5:20 Kotlin, Swift, etc to Go
5:24 - 6:44 Functional Langs: Haskell, F#, Scala, etc
6:44 - 8:20 Systems: C, C++, Rust
9:45 - 11:48 Historic Langs
14:40 - 16:03 Assembly down to transistors
16:03 - end Philosophy?
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."
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.
|
Final Reflective Journal
Entry: (due Monday of Exam Week)
In your final Growth Journal entry, you should reflect on the term 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 term, and looking back at your
weekly reflections, what have you learned that will help
you pick up new languages in the future? In addition to going in to
depth on topics, a thorough reflection will
also make connections with the learning objectives of the course, as
stated in the syllabus.
Reminder from Week 1:
Extra Goal (not mentioned in syllabus):
Understand the "inside jokes". For example, by the end
of the term, you should know why James
Iry's "A Brief, Incomplete, and Mostly Wrong History
of Programmng Languages" is funny.
|
| 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. | |