CS 450G - Fundamentals of Programming Languages
Credits: 3
Course Description
This course is an introduction to modern programming language concepts. It describes language generations with examples from each, such as Fortran II (first generation), Algol 60 (second generation), Pascal (third generation), and Ada (fourth generation). It also discusses non-traditional languages such as Prolog (logic programming), Smalltalk (object-oriented programming), and Lisp (functional programming). Instead of teaching entire programming languages, this course generalizes the principles that language designers should follow and shows how these principles apply to the syntax of various languages, as well as to their name, data, and control structures. In particular, the course emphasizes the central stack and how it is used to implement hierarchical name structures, recursive procedure invocation and return, parameter-passing modes, and first- and second-class values.
Prereqs: CS-315 and engineering standing.
Needed Skills
Students need a knowledge of programming in a modern imperative language, such as C, Pascal, C++, or Java.
Learning Outcomes
Students will learn about the principles underlying programming language design.
Students will be able to evaluate the name, data, and control structures as well as the syntax of a programming language with respect to those principles.
Students will have at least a rudimentary understanding of non-traditional paradigms such as functional, object-oriented, and logic programming.
Additional Comments
Students will reinforce the material with about four small programming projects, written in various languages such as Fortran, Pascal, Lisp, Smalltalk, and Prolog.
CAC Categories
Topic
|
Core
|
Advanced
|
Math
Fundamentals
|
1
|
1
|
Data
Structures
|
7
|
3
|
Algorithms
& Software Design
|
5
|
10
|
Computer
Organization and Architecture
|
2
|
0
|
Concepts
of Programming Languages
|
45
|
5
|
Social
and ethical issues
|
2
|
0
|
Total
|
62
|
19
|
(Note: This description differs from others in that topics are viewed as contributing to several categories. Thus, the units do not sum up to 45 credit hours.)
Math Fundamentals (2):
Core (1): Precedence of operations.
Advanced(1): Higher-order functions.
Data structures (10):
Core (7): Central stack for runtime storage. Pointers used for static and dynamic chains. Arrays and records as part of programming assignments.
Advanced(3): Heap storage. Closures to bind non-local referencing environments to code. K-D trees or other structures as part of programming assignments.
Algorithms and Software (15):
Core (5): Stack operations.
Advanced(10): Abstract data types. Object-oriented programming. Backtracking.
Computer Organization and Architecture (2): Core (2): Procedure call and return instructions. Memory organization.
Concepts of Programming Languages (50):
Core (40): Name structures, data structures, control structures, lexical structures of imperative and functional programming languages (such as Fortran, Algol, Pascal, Ada).
Advanced (10): Name structures, data structures, control structures, lexical structures of declarative programming languages (such as Prolog) and pure object-oriented programming languages (such as Smalltalk).
Social and ethical issues (2): Instructor and students discuss social responses to new software tools, both their ampliative and their reductive effects, and discuss what that makes new tools both attractive and feared.
Oral Communication (presentations)
>none
Written Communication
Students prepare extensive program documentation, and have to ensure that it be grammatical and properly spelled.
Coverage
Theoretical content 70%:
· Software tools in general, and programming languages as software tools.
· History and detail of first through fourth generation programming languages, functional programming, object-oriented programming, declarative programming.
Problem analysis: 15%:
· Design choices for programming languages as software tools.
Solution design: 15%:
· Homework requiring design and coding of algorithms in various programming languages.
Week by Week Course Outline
This is a sample outline. Exact outline will be determined by the instructor offering this course.
Weeks
|
Topics
|
1
|
Software
tools, pseudo-code interpreters
|
2-3
|
First
generation languages (Fortran)
|
3-4
|
Second
generation languages (Algol60)
|
5-6
|
Third
generation languages (Pascal)
|
7
|
Block
structure implementation
|
8-10
|
Fourth
generation languages (
|
11-12
|
Functional
programming (Lisp)
|
13
|
Object-oriented
programming (Smalltalk)
|
14-15
|
Logic
programming (Prolog)
|
Examinations
Exact details about examinations in this course are determined by the instructor offering the course. Typically there is one (1) in-class examination during the semester and a two-hour final examination. Specific details are made available in the syllabus at the start of each semester in which the course is offered.
Grading
A student's grade is determined by a weighted average of programming exercises, hour examinations, and the final examination. The faculty offering the course makes the details available at the start of the course. A typical weighting is:
· Programs - 50%
· Midterm - 25%
· Final Examination - 25%
Student evaluation and feedback
NOTE: 75% lecture - 25% recitations
Course Evaluation Questions:
37. I learned the principles underlying programming language design.
38. I learned how to evaluate the name, data, and control structures as well as the syntax of a programming language with respect to the principles underlying programming language design.
39. I have at least a rudimentary understanding of non-traditional programming-language paradigms such as functional, object-oriented, and logic programming.
Possible Textbooks
Bruce J. MacLennan,
Principles of Programming Languages, Third Edition: Design Evaluation and Implementation
Oxford University Press 1999
Robert W. Sebesta
Concepts of Programming Languages, Fourth edition
Benjamin Cummings, 1999.