Recent Changes - Search:

Test

edit SideBar

CISC181 /

ACM-BoKToJavaTopics

CISC 181: Intro to Computer Science 2

Programming Fundamentals

  • PF/Fundamental Constructs [4 of 9]
    • Variables, types, expressions, and assignment
    • Simple I/O
chapter 2
  • Conditional and iterative control structures
chapter 3, 4
  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
chapters 6,7
  • Representation of character data
  • Strings and string processing
chapter 9
  • Runtime storage management
  • References
chapter 8
  • Linked structures
chapter 25
  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)
chapters 8,10,11
  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
chapter 15
  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)
chapter 1
  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
chapters 8,10
  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
chapter 5
  • --Parameterization mechanisms (reference vs. value)
  • --Activation records and storage management
  • Type parameters and parameterized types
chapter 21
  • Modules in programming languages
chapter 8, online IIIG
  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
chapters 8,10,11,14
  • Collection classes and iteration protocols [not full coverage]
  • --Internal representations of objects and method tables
chapter 22
  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.
Edit - History - Print - Recent Changes - Search
Page last modified on February 01, 2011, at 04:45 PM