Programming Fundamentals (PF)
From CS2001 Wiki
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.
Contents |
PF/FundamentalConstructs [core]
Minimum core coverage time: 9 hours
Topics:
- 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:
- Analyze and explain the behavior of simple programs involving the fundamental programming constructs covered by this unit.
- Modify and expand short programs that use standard conditional and iterative control structures and functions.
- 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.
- Choose appropriate conditional and iteration constructs for a given programming task.
- Apply the techniques of structured (functional) decomposition to break a program into smaller pieces.
- Describe the mechanics of parameter passing.
PF/AlgorithmicProblemSolving [core]
Minimum core coverage time: 6 hours
Topics:
- 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:
- Discuss the importance of algorithms in the problem-solving process.
- Identify the necessary properties of good algorithms.
- Create algorithms for solving simple problems.
- Use pseudocode or a programming language to implement, test, and debug algorithms for solving simple problems.
- Describe strategies that are useful in debugging.
PF/DataStructures [core]
Minimum core coverage time: 10 hours
Topics:
- 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:
- Describe the representation of numeric and character data.
- Understand how precision and round-off can affect numeric calculations.
- Discuss the use of primitive data types and built-in data structures.
- Describe common applications for each data structure in the topic list.
- Implement the user-defined data structures in a high-level language.
- Compare alternative implementations of data structures with respect to performance.
- Write programs that use each of the following data structures: arrays, strings, linked lists, stacks, queues, and hash tables.
- Compare and contrast the costs and benefits of dynamic and static data structure implementations.
- Choose the appropriate data structure for modeling a given problem.
PF/Recursion [core]
Minimum core coverage time: 4 hours
Topics:
- The concept of recursion
- Recursive mathematical functions
- Simple recursive functions
- Divide-and-conquer strategies
- Recursive backtracking
Learning objectives:
- Describe the concept of recursion and give examples of its use.
- Identify the base case and the general case of a recursively defined problem.
- Compare iterative and recursive solutions for elementary problems such as factorial.
- Describe the divide-and-conquer approach.
- Implement, test, and debug simple recursive functions and procedures.
- Determine when a recursive solution is appropriate for a problem.
PF/EventDriven [core]
Minimum core coverage time: 4 hours"
"Topics:
- Event-handling methods
- Event propagation
- Exception handling
Learning objectives:
- Explain the difference between event-driven programming and command-line programming.
- Design, code, test, and debug simple event-driven programs that respond to user events.
- Develop code that responds to exception conditions raised during execution.
PF/ObjectOriented [core]
Minimum core coverage time: 8 hours
Topics:
- 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:
- Justify the philosophy of object-oriented design and the concepts of encapsulation, abstraction, inheritance, and polymorphism.
- Design, implement, test, and debug simple programs in an object-oriented programming language.
- Describe how the class mechanism supports encapsulation and information hiding.
- Design, implement, and test the implementation of “is-a” relationships among objects using a class hierarchy and inheritance.
- Compare and contrast the notions of overloading and overriding methods in an object-oriented
language.
PF/FoundationsInformationSecurity [core]
Minimum core coverage time: 4 hours
Topics:
- 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:
- Explain the objectives of information security
- Analyze the tradeoffs inherent in security
- Explain the importance and application of each of confidentiality, integrity, and availability
- Understand the basic categories of threats to computers and networks
- Discuss issues for creating security policy for a large organization
- Defend the need for protection and security, and the role of ethical considerations in computer use
- Add a very simple risk-assessment learning outcome here
PF/SecureProgramming [core]
Minimum core coverage time: 2 hour
Topics
- 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:
- Rewrite a simple program to remove a simple vulnerability
- Explain why or why not a buffer overflow is possible in the programming language you know best
- 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.
