CSCI 330

Programming Languages

Coordinator: David Hutchens

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

  1. Represent elementary and structured data types.
  2. Explain various models for data control, scope, lifetime, and type checking of variables.
  3. Explain and use various parameter passing techniques.
  4. Illustrate the flexibility of dynamic type binding over static type binding.
  5. Explain and compare various models of run-time storage management.
  6. Summarize non-procedural programming paradigms; compare non-procedural programming paradigms to the procedural programming paradigm.
  7. Perform software requirements analysis and develop and/or interpret software specifications.
  8. Describe various software design and implementation techniques and be able to use at least two of them to design and implement software.
  9. Describe a software verification/validation technique and use it to verify a software artifact.
  10. Explain risks of computing with examples.
  11. Give a description of the History of Programming Languages.
  12. Write a technical paper on a Programming Languages topic.
  13. 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.)