• View
• Edit
• History
• Print

ACM-BoK

CISC 181: Intro to Computer Science 2

Programming Fundamentals

• PF/Fundamental Constructs [4 of 9]
  • Variables, types, expressions, and assignment
  • Simple I/O
  • Conditional and iterative control structures
  1. Modify and expand short programs that use standard conditional and iterative control structures and functions.
  2. 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.
  3. Choose appropriate conditional and iteration constructs for a given programming task.
  4. Apply the techniques of structured (functional) decomposition to break a program into smaller pieces.
• PF/Algorithmic Problem Solving [2 of 6]
  • The role of algorithms in the problem-solving process
  • Implementation strategies for algorithms
  • Debugging strategies
  1. Identify the necessary properties of good algorithms.
  2. Create algorithms for solving simple problems.
  3. Use pseudocode or a programming language to implement, test, and debug algorithms for solving simple problems.
  4. Describe strategies that are useful in debugging.

propose trim to 3 of 10 -> 220 (hashing, advanced trees)

• PF/DataStructures [4 of 10]
  • Arrays
  • Representation of character data
  • Strings and string processing
  • Runtime storage management
  • References
  • Linked structures
  1. Discuss the use of primitive data types and built-in data structures.
  2. Describe common applications for each data structure in the topic list.
  3. Implement the user-defined data structures in a high-level language.
  4. Write programs that use each of the following data structures: arrays, strings, linked lists. [no trees, stacks, queues, dictionaries (associative structure not necessarily using hash)]
• PF/Object Oriented [7 of 8]
  • Object-oriented design
  • Encapsulation and information-hiding
  • Separation of behavior and implementation
  • Classes and subclasses
  • Inheritance (overriding, dynamic dispatch)
  • Polymorphism (subtype polymorphism vs. inheritance)
  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 language.

propose cut -> 220

• AL/Basic Analysis [1 of 4]

propose cut -> 220

• AL/Fundamental Algorithms [2 of 12]

propose trim to [1 of 7] -> 260

• AR/Digital Logic and Data Representation [2 of 7]
  • Representation of text, audio, and images
  1. Understand how numbers, text, images, and sound can be represented in digital form and the limitations of such representations

propose cut -> 220

• OS/Overview of Operating Systems [1 of 2]
• PL/Overview [1 of 2]
  • History of programming languages
  • Brief survey of programming paradigms
  • Procedural languages
  • Object-oriented languages
  • Functional language
  • The effects of scale on programming methodology
  1. Summarize the evolution of programming languages illustrating how this history has led to the paradigms available today.
  2. Identify at least one distinguishing characteristic for each of the programming paradigms covered in this unit.
  3. Distinguish between programming-in-the-small and programming-in-the-large.
• PL/Basic Language translation [1 of 2]
  • Comparison of interpreters and compilers
  • Language translation phases (lexical analysis, parsing, code generation, optimization)
  1. Compare and contrast compiled and interpreted execution models, outlining the relative merits of each.
  2. Describe the phases of program translation from source code to executable code and the files produced by these phases.
• PL/Declarations and Types [1 of 3]
  • The conception of types as a set of values together with a set of operations
  • Declaration models (binding, visibility, scope, and lifetime)
  • Overview of type-checking
  • Garbage collection
  1. Explain the value of declaration models, especially with respect to programming-in-the-large.
  2. Identify and describe the properties of a variable such as its associated address, value, scope, persistence, and size.
  3. Discuss type incompatibility.

propose trim to 1 of 3 -> 220

• PL/Abstraction Mechanisms [2 of 3]
  • Procedures, functions, and iterators as abstraction mechanisms
  • --Parameterization mechanisms (reference vs. value)
  • --Activation records and storage management
  • Type parameters and parameterized types
  • Modules in programming languages
  1. Explain how abstraction mechanisms support the creation of reusable software components.
  2. --Demonstrate the difference between call-by-value and call-by-reference parameter passing.
  3. Defend the importance of abstractions, especially with respect to programming-in-the-large.
  4. --Describe how the computer system uses activation records to manage program modules and their data.

propose increase to 9 of 10 <- 220

• PL/Object Oriented Programming [6 of 10]
  • Object-oriented design
  • Encapsulation and information-hiding
  • Separation of behavior and implementation
  • Classes and subclasses
  • Inheritance (overriding, dynamic dispatch)
  • Polymorphism (subtype polymorphism vs. inheritance)
  • Class hierarchies
  • Collection classes and iteration protocols [not full coverage]
  • --Internal representations of objects and method tables
  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 language.
  6. Explain the relationship between the static structure of the class and the dynamic structure of the instances of the class.
  7. Describe how iterators access the elements of a container.

Software Engineering

propose cut -> 275

• SE/Software Design [1 of 8]
• SE/Using APIs [1 of 5]
  • Programming using APIs
  • Class browsers and related tools
  1. Explain the value of application programming interfaces (APIs) in software development.
  2. Use class browsers and related tools during the development of applications using APIs.
• SE/ToolsAndEnvironments [1 of 3]
  • Programming environments
  • Testing tools including static and dynamic analysis tools
  1. Analyze and evaluate a set of tools in a given area of software development (e.g., management, modeling, or testing). [testing only]

Optional

propose add 3 of 4 <- 275

• PF/EventDrivenProgramming
  • Event-handling methods
  • Event propagation
  • Exception handling
  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.

Net changes to core hours (not including optional):

181: 37 -> 32

220: 22 -> 25

260: 9 -> 10

275: 26 -> 27

Summary of changes: some data structures and OS/compiler issues moved to 220, most OO moved from 220 to 181, some SE moved to 275, data representation moved to 260