Programming Languages History and Fundamentals by kgj11073

VIEWS: 162 PAGES: 6

More Info
									Computing Curricula - Computer Engineering Body of Knowledge                              –1–
Strawman Draft (10/02/03)

Programming Fundamentals (CE-PRF)
  CE-PRF0. History and overview of programming fundamentals [core]
  CE-PRF1. Fundamental programming constructs [core]
  CE-PRF2. Algorithms and problem-solving [core]
  CE-PRF3. Fundamental data structures [core]
  CE-PRF4. Programming Paradigms [core]
  CE-PRF5: Recursion [core]
  CE-PRF6. Object-oriented programming
  CE-PRF7. Event-driven and concurrent programming
  CE-PRF8. Using APIs

Competency in a programming language is prerequisite to the study of computer
engineering. Undergraduate programs must teach students how to use at least one
programming language. The difficulty of achieving the necessary level of fluency in a
programming language is further complicated by the need to include more advanced
techniques than were necessary a few years ago. The core topics in this unit cover the
basic pieces that should be covered independent of a particular programming language as
programming languages tend to come and go over the years.

Over the past decade, object-oriented programming, event-driven applications, and the
use of extensive APIs (application programming interfaces) have become fundamental
tools that some computer engineering students need early in their academic program.
These concepts may be included in a program that only teaches an object oriented
language such as C++ or Java.

CE-PRF0. History and overview of programming fundamentals [core]
Suggested time: 1 hour

Topics:
     Indicate some reasons for studying programming fundamentals.
     Highlight some people that influenced or contributed to the area of programming
     fundamentals.
     Indicate some important topic areas such as programming constructs, algorithms,
     problem solving, data structures, programming paradigms, recursion, object-
     oriented programming, event-driven programming, and concurrent programming.
     Contrast between an algorithm and a data structure.
     Distinguish between a variable, type, expression, and assignment.
     Highlight the role of algorithms in solving problems.
     Describe some of the fundamental data structures such as array, record, stack, and
     queue.
     Explain the various programming paradigms such as procedural, functional, logic,
     and object oriented.
     Explain how divide-and-conquer strategies lend themselves to recursion.
     Explore some additional resources associated with programming fundamentals.
     Explain the purpose and role of programming fundamentals in computer
     engineering.
Computing Curricula - Computer Engineering Body of Knowledge                       –2–
Strawman Draft (10/02/03)



Learning objectives:
     Identify some contributors to programming fundamentals and relate their
     achievements to the knowledge area.
     Define the meaning of algorithm and data structure.
     Know the reasons that a way to solve problems is by using algorithms.
     Distinguish the difference between a stack and a queue.
     Identify the difference between various programming paradigms.
     Explain recursion and how it works.
     Describe how computer engineering uses or benefits from programming
     fundamentals.

CE-PRF1. Fundamental programming constructs [core]
Suggested time: 7 hours

Topics:
   Basic syntax and semantics of a high-level language
   Variables, types, expressions, and assignment
   Simple I/O
   Conditional and iterative control structures
   Functions and parameter passing

Learning objectives:
1. Analyze and explain the behavior of simple programs involving the fundamental
   programming constructs covered by this unit.
2. Write 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 procedures and functions.

CE-PRF2. Algorithms and problem-solving [core]
Suggested time: 9 hours                                                            Deleted: 6


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
   Structured decomposition

Learning objectives:
1. Define the basic properties of an algorithm.
2. Develop algorithms for solving simple problems.
Computing Curricula - Computer Engineering Body of Knowledge                                  –3–
Strawman Draft (10/02/03)

3. Use a suitable programming language to implement, test, and debug algorithms for
   solving simple problems.
4. Apply the techniques of structured decomposition to break a program into smaller
   pieces.

CE-PRF3. Fundamental data structures [core]
Suggested time: 17 hours                                                                      Deleted: 14


Topics:
   Primitive types
   Arrays
   Records
   Strings and string processing
   Data representation in memory
   Static, stack, and heap allocation
   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                                           Comment: Comment from session at
                                                                                              FIE: Is there some way we can define to
                                                                                              what depth this should be covered?
Learning objectives:
                                                                                               DJN: I believe that the learning
1. Identify data structures that could be used to represent specific types of information     objectives should show that
   and discuss the tradeoffs among the different possibilities.
2. Write programs that use each of the following data structures: arrays, records, strings,
   linked lists, stacks, queues, and hash tables.
3. Describe how these data structures are allocated and represented in memory.

CE-PRF4. Programming Paradigms [core]
Suggested time: 8 hours

Topics:
   Procedural programming
   Functional programming
   Object-oriented design
   Encapsulation and information-hiding
   Separation of behavior and implementation
   Classes, subclasses, and inheritance
   Event-Driven programming

Learning objectives:
1. To identify the paradigm used by pseudo-code snippets.
2. To identify the appropriate paradigm for a given programming problem.
Computing Curricula - Computer Engineering Body of Knowledge                                –4–
Strawman Draft (10/02/03)



CE-PRF5. Recursion [core]
Suggested time: 6 hours

Topics:
   The concept of recursion
   Recursive mathematical functions
   Divide-and-conquer strategies                                                            Comment: It was thought that these are
                                                                                            useless academic exercizes.
   Recursive backtracking
                                                                                            Deleted: Simple recursive procedures¶
   Implementation of recursion

Learning objectives:
1. Explain the concept of recursion.
2. Explain the structure of the divide-and-conquer approach.
3. Write, test, and debug simple recursive functions and procedures.
4. Describe how recursion can be implemented using a stack.

CE-PRF6. Object-oriented programming

Topics:
   Polymorphism
   Class hierarchies
   Collection classes and iteration protocols
   Fundamental design patterns

Learning objectives:
1. Outline the philosophy of object-oriented design and the concepts of encapsulation,
   subclassing, inheritance, and polymorphism.
2. Design, code, test, and debug simple programs in an object-oriented programming
   language.
3. Select and apply appropriate design patterns in the construction of an object-oriented
   application.

CE-PRF7. Event-driven and concurrent programming

Topics:
   Event-handling methods                                                                   Comment: DJN: should this just be in
                                                                                            the Embedded Systems KA? Or should
   Event propagation                                                                        the Embedded Systems KA reference this
   Managing concurrency in event handling                                                   area?
   Exception handling
Computing Curricula - Computer Engineering Body of Knowledge                         –5–
Strawman Draft (10/02/03)

Learning objectives:
1. Design, code, test, and debug simple event-driven programs that respond to user
   events.
2. Defend the need for concurrency control and describe at least one method for
   implementing it.
3. Develop code that responds to exception conditions raised during execution.

CE-PRF8. Using APIs

Topics:
   API programming
   Class browsers and related tools
   Programming by example
   Debugging in the API environment
   Component-based computing
   Middleware

Learning objectives:
1. Explain the value of application programming interfaces (APIs) in software
   development.
2. Design, write, test, and debug programs that use large-scale API packages.
Last Update: 10/02/03

								
To top