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).
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 .
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.)
|
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?
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:
Wednesday.)
Week 1
Reflective Journal Entry (See F1 for description)
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
|
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.
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
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 |
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. |
| F5 |
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?
|
| 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)
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 (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:
|
| F6 |
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: No Journal entry
this week!
|
| 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 ? |
Jay Interpreter
Programming Assignment:
|
| 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
|
| 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)
|
Read through and compare all of the early attempts at
making a board and accessing its elements:
|
| W8 |
Reading:
Data Abstraction and Encapsulation
Read Chapter 11 in Sebesta.
Read Section 2.10 in Sebesta.
|
|
| 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?
|
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)
|
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. |
| 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 |
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!
|
| 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, 2024: No class
Reminder from Week 1:
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.
|
| 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. | |