Programming Fundamentals (PF)

From CS2001 Wiki

Jump to: navigation, search

Fluency in a programming language is prerequisite to the study of most of computer science. Undergraduate computer science programs must teach students how to use at least one programming language well; furthermore, computer science programs should teach students to become competent in languages that make use of the object-oriented and event-driven programming paradigms.

This knowledge area includes those skills and concepts that are essential to programming practice independent of the underlying paradigm. As a result, this area includes units on fundamental programming concepts, basic data structures, algorithmic processes, and basic security. These units, however, by no means cover the full range of programming knowledge that a computer science undergraduate must know. Many of the other areas—most notably Programming Languages (PL) and Software Engineering (SE)—also contain programming-related units that are part of the undergraduate core. In most cases, these units could equally well have been assigned to either Programming Fundamentals or the more advanced area.


PF/FundamentalConstructs [core]

Minimum core coverage time: 9 hours


  • Basic syntax and semantics of a higher-level language
  • Variables, types, expressions, and assignment
  • Simple I/O
  • Conditional and iterative control structures
  • Functions and parameter passing
  • Structured decomposition

Learning objectives:

  1. Analyze and explain the behavior of simple programs involving the fundamental programming constructs covered by this unit.
  2. Modify and expand short programs that use standard conditional and iterative control structures and functions.
  3. Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: basic computation, simple I/O, standard conditional and iterative structures, and the definition of functions.
  4. Choose appropriate conditional and iteration constructs for a given programming task.
  5. Apply the techniques of structured (functional) decomposition to break a program into smaller pieces.
  6. Describe the mechanics of parameter passing.

PF/AlgorithmicProblemSolving [core]

Minimum core coverage time: 6 hours


  • Problem-solving strategies
  • The role of algorithms in the problem-solving process
  • Implementation strategies for algorithms
  • Debugging strategies
  • The concept and properties of algorithms

Learning objectives:

  1. Discuss the importance of algorithms in the problem-solving process.
  2. Identify the necessary properties of good algorithms.
  3. Create algorithms for solving simple problems.
  4. Use pseudocode or a programming language to implement, test, and debug algorithms for solving simple problems.
  5. Describe strategies that are useful in debugging.

PF/DataStructures [core]

Minimum core coverage time: 10 hours


  • Representation of numeric data
  • Range, precision, and rounding errors
  • Arrays
  • Representation of character data
  • Strings and string processing
  • Runtime storage management
  • Pointers and references
  • Linked structures
  • Implementation strategies for stacks, queues, and hash tables
  • Implementation strategies for graphs and trees
  • Strategies for choosing the right data structure

Learning objectives:

  1. Describe the representation of numeric and character data.
  2. Understand how precision and round-off can affect numeric calculations.
  3. Discuss the use of primitive data types and built-in data structures.
  4. Describe common applications for each data structure in the topic list.
  5. Implement the user-defined data structures in a high-level language.
  6. Compare alternative implementations of data structures with respect to performance.
  7. Write programs that use each of the following data structures: arrays, strings, linked lists, stacks, queues, and hash tables.
  8. Compare and contrast the costs and benefits of dynamic and static data structure implementations.
  9. Choose the appropriate data structure for modeling a given problem.

PF/Recursion [core]

Minimum core coverage time: 4 hours


  • The concept of recursion
  • Recursive mathematical functions
  • Simple recursive functions
  • Divide-and-conquer strategies
  • Recursive backtracking

Learning objectives:

  1. Describe the concept of recursion and give examples of its use.
  2. Identify the base case and the general case of a recursively defined problem.
  3. Compare iterative and recursive solutions for elementary problems such as factorial.
  4. Describe the divide-and-conquer approach.
  5. Implement, test, and debug simple recursive functions and procedures.
  6. Determine when a recursive solution is appropriate for a problem.

PF/EventDriven [core]

Minimum core coverage time: 4 hours"


  • Event-handling methods
  • Event propagation
  • Exception handling

Learning objectives:

  1. Explain the difference between event-driven programming and command-line programming.
  2. Design, code, test, and debug simple event-driven programs that respond to user events.
  3. Develop code that responds to exception conditions raised during execution.

PF/ObjectOriented [core]

Minimum core coverage time: 8 hours


  • Object-oriented design
  • Encapsulation and information-hiding
  • Separation of behavior and implementation
  • Classes and subclasses
  • Inheritance (overriding, dynamic dispatch)
  • Polymorphism (subtype polymorphism vs. inheritance)

Learning objectives:

  1. Justify the philosophy of object-oriented design and the concepts of encapsulation, abstraction, inheritance, and polymorphism.
  2. Design, implement, test, and debug simple programs in an object-oriented programming language.
  3. Describe how the class mechanism supports encapsulation and information hiding.
  4. Design, implement, and test the implementation of “is-a” relationships among objects using a class hierarchy and inheritance.
  5. Compare and contrast the notions of overloading and overriding methods in an object-oriented


PF/FoundationsInformationSecurity [core]

Minimum core coverage time: 4 hours


  • Role and purpose of computer and network security
  • Security goals: confidentiality, integrity, availability triad
  • Security standards and policies
  • Security mindset
  • Defense in depth
  • Common threats: worms, viruses, trojans, denial of service
  • Risk assessment and cost-benefit analyses
  • Security versus usability, time, and/or money tradeoffs

Learning Objectives:

  1. Explain the objectives of information security
  2. Analyze the tradeoffs inherent in security
  3. Explain the importance and application of each of confidentiality, integrity, and availability
  4. Understand the basic categories of threats to computers and networks
  5. Discuss issues for creating security policy for a large organization
  6. Defend the need for protection and security, and the role of ethical considerations in computer use
  7. Add a very simple risk-assessment learning outcome here

PF/SecureProgramming [core]

Minimum core coverage time: 2 hour


  • Important of checking for and avoiding array and string overflows
  • Programming language constructs to avoid and alternatives
  • How attackers use overflows to smash the run-time stack

Learning Objectives:

  1. Rewrite a simple program to remove a simple vulnerability
  2. Explain why or why not a buffer overflow is possible in the programming language you know best
  3. Explain why one or more language constructs may lead to security problems such as overflows.
To give feedback on this area of revision, go to here and use your ACM user name and login.

Copyright © 2008, ACM, Inc. and IEEE, Inc.

Personal tools