CSCI 330

Programming Languages

Coordinator: chris cain

Credits: 4.0


Introduction to the fundamental principles of programming language design, semantics, and implementation. Structure and vocabulary of modern programming languages. Programming language topics include formal semantics of programming, name binding, scope, data types, type systems, control flow, object orientation, scripting languages, functional languages, polymorphism, and concurrency. Labs and assignments will include experience in writing programs in a nonprocedural programming paradigm.

Prerequisite or Corequisite

C- or higher in CSCI 362

Sample Textbooks

Course Outcomes

At the end of this course, a successful student will be able to

  1. Apply syntax-related concepts such as context-free grammars and parse trees.
  2. Apply semantics-related concepts such as denotational mapping functions and weakest preconditions.
  3. Understand and differentiate between various models for data control, scope, lifetime, and type checking of variables.
  4. Analyze and apply various parameter passing techniques.
  5. Explain and compare various models of run-time storage management.
  6. Compare non-procedural programming paradigms to the procedural programming paradigm.
  7. Design and implement programs in a non-procedural programming paradigm.
  8. Distinguish between compile-time vs. run-time activities
  9. Write a technical paper on a Programming Languages topic.
  10. Give an oral presentation on a Programming Languages topic.

Major Topics Covered

  1. History and overview of programming languages
    1. Early languages
    2. Modern procedural languages
    3. Non-procedural languages
  2. History and overview of Software Engineering
    1. Early programming techniques
    2. Origin and definition of Software Engineering
    3. Software development paradigms
    4. Relationship of paradigms to languages
  3. Binding
    1. Binding time
    2. Static binding
    3. Dynamic binding
    4. Name bindings
    5. Storage bindings
    6. Type bindings
  4. Data control, sharing, and type checking
    1. Scope
    2. Lifetime
    3. Type checking strategies
    4. Storage allocation strategies
    5. Strategies for recovery and reuse of heap-based storage
  5. Sequence control
    1. Co-routines
    2. Exception handling
    3. Error checking and defensive programming
    4. Parallel programming constructs
  6. Subprograms
    1. Implementation of parameter passing mechanisms
    2. Non-recursive call and return mechanism
    3. Recursive call and return mechanism
    4. Co-routine call and resume mechanism
  7. Software development
    1. Requirements and specification
    2. Design
    3. Implementation
    4. Verification and validation
  8. Programming paradigms and related languages
    1. Abstract data type
    2. Object-oriented languages
    3. Functional languages
    4. Logical languages

Sample Laboratory Projects

  1. Test the relationship between name access and structure access for a program written in a non-ADT language and an ADT language. Use experimental results to determine: (1) what is the extent that information hiding can be enforced in non-ADT languages and what are the conditions for doing so? (2) what is required for a language to be an ADT-language?
  2. Implement a parallel algorithm in a programming language supporting concurrent processes. (1 week.)
  3. Implement error checking in a programming language supporting exception handling.
  4. Test the difference between static type binding and dynamic type binding in an object-oriented language. Use experimental results to determine the necessity of dynamic type binding for code that is intended to be reusable.
  5. Design a program using functional design tools (data flow diagrams and structure charts). (1 week.)
  6. Implement the functional design (1 week).
  7. Design a program using object-oriented design tools (informal strategy, object/operation table, class hierarchy diagram, message interface table). (2 weeks.)
  8. Implement the object-oriented design. (2 weeks.)
  9. Implement a recursive-descent parser. (1 week.)