Content Outline and Competencies:

I. Software Development Careers and Software Applications

A. Describe different types of careers available to software developers.

B. Identify real-world applications that are based upon computer programs.

II. Internal and External Data Representation

A. Convert characters to and from ASCII (American Standard Code for Information Interchange) code.

B. Convert among binary, decimal and hexadecimal numbers.

C. Discuss data storage.

III. Object-Oriented Software Development in a Graphical Framework

A. Utilize an Integrated Development Environment (IDE) that presents a code editor and an execution world in a visual manner.

B. Manage project components.

C. Describe the visual interactive execution environment as presented on a computer screen.

1. Describe the two-dimensional grid world composed of pixels.

2. Describe the properties of images.

D. Use the Application Program Interface (API) documentation to select appropriate classes and methods needed to solve the current programming problem.

E. Single step program execution.

F. Inspect object instance data during program execution.

G. Describe the class hierarchy presented in the IDE.

IV. Problem-Solving Techniques for Software Development

A. Develop logic to solve computer programs.

B. Represent problems and solutions.

1. Use flowcharts to represent logical flow.

2. Use hierarchy charts to represent relationships among classes.

3. Use pseudo-code to represent algorithms.

C. Discuss top-down design.

D. Explain the software development life cycle.

E. Break a larger problem into smaller, more manageable units.

F. Develop and implement plans to test solutions.

G. Trace program flow manually and with a debugger.

H. Identify needed classes.

1. Identify needed instance and static data for the class.

2. Identify needed instance and static methods for the class.

V. Fundamental Statements and Processes

A. Declare variables using appropriate data types.

B. Use assignment operators.

C. Use arithmetic, relational and logical operators.

D. Use branching statements.

E. Use at least two different types of looping statements.

F. Process user input.

G. Generate user output.

H. Declare and manipulate arrays.

I. Generate random numbers to incorporate random behavior in objects.

J. Dynamically create and remove objects during program execution.

K. Utilize accumulator variables.

VI. Methods

A. Utilize built-in methods from the Application Program Interface (API).

B. Write methods.

C. Call methods and pass parameters.

D. Process returned values.

VII. Object-Oriented Methodology

A. Discuss advantages of object-oriented techniques.

B. Utilize objects and methods from built-in classes.

C. Create user-defined classes.

1. Create and utilize static and non-static instance variables.

2. Create and utilize static and non-static methods.

3. Create constructors to initialize instance variables.

4. Properly use public and private access modifiers.

5. Use inheritance.

D. Instantiate objects from classes.

E. Implement object interaction.

F. Analyze real-world visual applications (such as animations, games, simulations, models and apps) to identify language constructs and strategies that will help to solve the problem.

1. Identify objects, their data and methods used in the application.

2. Define appropriate classes and code the methods.

3. Create a user application that implements the visual application that was originally analyzed.

VIII. Event-Driven Programming

A. List different types of event triggers.

B. Use built-in classes to capture events.

C. Write event handlers to process events, including key pressed, mouse clicked and mouse moved.

Content Outline and Competencies:

I. Computer Systems and Ethics

A. Describe basic hardware components.

1. Describe primary memory.

2. Describe the central processing unit.

3. Describe secondary memory.

4. Describe peripherals.

B. Describe basic software components.

1. Describe operating systems.

2. Describe high-level and machine languages.

3. Describe compilers.

C. Examine ethics

1. Examine ethics in the context of software development.

2. Examine the impact of ethics violations on software developers.

3. Examine the impact of ethics violations on software users.

II. Problem-Solving in Software Development

A. Define the problem.

B. Develop a solution.

1. Utilize top-down design.

2. Consider previous problems and solutions.

3. Reuse pertinent algorithms.

4. Represent algorithms with pseudo-code.

5. Identify input, output, processing and modules.

C. Code the solution.

D. Test the solution.

1. Perform unit and integration testing.

2. Select appropriate test data.

3. Trace code by hand (desk-checking) and with a debugger.

4. Evaluate code efficiency and simplicity.

III. Fundamental Programming Features

A. Declare and initialize variables and constants.

B. Use built-in operators to create expressions and statements.

1. Write assignment statements.

2. Create expressions with arithmetic, relational and logical operators.

3. Use the conditional (ternary) operator.

4. Evaluate expressions using rules of operator precedence.

5. Compare strings and numeric types.

6. Dereference and assign values to pointers.

C. Perform input and output.

1. Retrieve data from the keyboard.

2. Retrieve data from input files.

3. Write data to the console window.

4. Write data to output files.

D. Call built-in mathematical functions.

E. Implement type-casting.

F. Control program flow.

1. Implement selection statements.

a. Write code with if, else and else-if statements.

b. Use switch statements.

c. Write nested selection statements.

2. Implement repetition statements

a. Write while, for and do loops.

b. Create nested loops.

c. Analyze break and continue semantics.

G. Trap errors using selection or repetition.

IV. Procedures

A. Define and call functions with void and non-void return values.

B. Declare functions (prototyping).

C. Implement pass-by-value and pass-by-reference parameters.

D. Differentiate between actual and formal parameters.

E. Analyze and write elementary recursive code.

F. Analyze variable scope and lifetime.

G. Implement static variables.

V. Fundamental Data Structures and Algorithms

A. Implement single dimensional arrays.

1. Implement an array of integers.

2. Implement null-terminated strings.

B. Implement two-dimensional arrays.

C. Implement dynamic arrays.

1. Use new and delete to manage memory.

2. Declare pointers.

D. Search arrays.

1. Implement sequential search.

2. Implement binary search.

E. Sort arrays.

1. Sort data using bubble sort.

2. Sort data using selection sort.

3. Sort data using insertion sort.

F. Implement structures.

G. Implement an array of structures.

VI. Object-oriented Programming

A. Write code using the built-in string class and associated methods.

B. Write code using the built-in vector class and associated methods.

C. Implement encapsulation and data abstraction by writing user-defined classes.

D. Differentiate between private and public access modifiers.

E. Hide member data.

F. Write accessors, mutators and other member functions that process member data.

G. Write code that utilizes objects.

H. Implement an array of objects.

VII. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.

VIII. Professional Development Environment

A. Write code using a professional, integrated development environment (IDE)

B. Utilize key editor features.

C. Debug code using the integrated debugger.

D. Include and use standard libraries.

Content Outline and Competencies:

I. Computer Systems and Ethics

A. Describe basic hardware components.

1. Describe primary memory.

2. Describe the central processing unit.

3. Describe secondary memory.

4. Describe peripherals.

B. Describe basic software components.

1. Describe operating systems.

2. Describe high-level and machine languages.

3. Describe compilers.

C. Examine ethics.

1. Examine ethics in the context of software development.

2. Examine the impact of ethics violations on software developers.

3. Examine the impact of ethics violations on software users.

II. Problem-Solving in Software Development

A. Define the problem.

B. Develop a solution.

1. Utilize top-down design.

2. Consider previous problems and solutions.

3. Re-use pertinent algorithms.

4. Represent algorithms with pseudo-code.

5. Identify input, output, processing and modules.

C. Code the solution.

D. Test the solution.

1. Perform unit and integration testing.

2. Select appropriate test data.

3. Trace code by hand (desk-checking) and with a debugger.

4. Evaluate code efficiency and simplicity.

III. Fundamental Programming Features

A. Declare and initialize variables and constants.

B. Use built-in operators to create expressions and statements.

1. Write assignment statements

2. Create expressions with arithmetic, relational and logical operators

3. Use the conditional (ternary) operator

4. Evaluate expressions using rules of operator precedence

5. Compare strings and numeric types

C. Perform input and output.

1. Retrieve data from the keyboard

2. Retrieve data from input files

3. Write data to the console window

4. Write data to output files

5. Connect to and process data from a database

D. Perform data conversions and type-casting.

E. Control program flow.

1. Implement selection statements

a. Write code with if, else and else-if statements

b. Use switch statements

c. Write nested selection statements

2. Implement repetition statements

a. Write while, for, do and foreach loops

b. Create nested loops

c. Analyze break and continue semantics

F. Trap errors using selection or repetition.

G. Implement exception handling.

H. Write code using enumerations.

IV. Fundamental Data Structures and Algorithms

A. Implement single-dimensional arrays.

B. Implement two-dimensional arrays.

C. Search arrays.

1. Implement sequential search

2. Implement binary search

D. Sort arrays.

1. Sort data using bubble sort

2. Sort data using selection sort

3. Sort data using insertion sort

E. Implement lists.

F. Write LINQ (Language Integrated Query) queries.

V. Object-Oriented Programming

A. Write code using the Math and String class methods.

B. Implement encapsulation and data abstraction by creating user-defined classes.

C. Write code that utilizes user-defined classes.

D. Differentiate between public and private access modifiers.

E. Analyze variable scope and lifetime.

F. Create and utilize instance variables and properties.

1. Implement private instance variables (fields)

2. Implement static instance variables (fields)

3. Create auto-implemented properties

4. Create properties that use the “value” keyword

G. Create and utilize methods.

1. Write accessors, mutators and other methods that process fields

2. Pass parameter data by value

2. Pass parameter data by reference using the “ref” and “out” keywords

3. Recognize which data types default to pass-by-value and which default to pass-by-reference

4. Implement static methods

5. Analyze and write elementary recursive methods

6. Differentiate between actual and formal parameters

H. Implement an array of objects.

VI. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.

VII. Professional Development Environment

A. Write code using a professional, integrated development environment (IDE)

B. Utilize key editor features.

C. Debug code using the integrated debugger.

Content Outline and Competencies:

I. Computer Systems and Ethics

A. Describe basic hardware components.

1. Describe primary memory.

2. Describe the central processing unit.

3. Describe secondary memory.

4. Describe peripherals.

5. Describe file systems.

B. Describe basic software components.

1. Describe operating systems.

2. Describe high-level and machine languages.

3. Describe compilers.

C. Examine ethics.

1. Examine ethics in the context of software development.

2. Examine the impact of ethics violations on software developers.

3. Examine the impact of ethics violations on software users.

II. Problem Solving in Object-Oriented Software Development

A. Define the problem.

1. Design class and interface specifications.

2. Identify composition and inheritance relationships.

3. Identify polymorphic methods.

4. Identify dynamic binding.

5. Identify procedural and data abstraction.

6. Identify abstract classes.

7. Identify the Java features needed to implement event-driven programs.

B. Develop a solution.

1. Utilize top-down design.

2. Consider previous problems and solutions.

3. Reuse pertinent algorithms.

4. Represent algorithms using current design methodologies.

5. Identify input, output, processing and modules.

C. Code the solution.

D. Test the solution.

1. Perform unit and integration testing.

2. Select appropriate test data.

3. Trace code by hand (desk-checking) and with a debugger.

4. Evaluate code efficiency and simplicity.

III. Fundamental Programming Features

A. Declare and initialize variables and constants.

1. Utilize primitive data types.

2. Utilize programmer defined data types.

B. Use built-in operators to create expressions and statements.

1. Write assignment statements.

2. Create expressions with arithmetic, relational and logical operators.

3. Use the conditional (ternary) operator.

4. Evaluate expressions using rules of operator precedence.

5. Compare strings and numeric primitive types.

6. Compare reference and primitive types.

C. Perform input and output.

1. Retrieve data from the keyboard or a graphical user interface (GUI).

2. Retrieve data from input files.

3. Write data to the console window or GUI.

4. Write data to output files.

5. Connect to and process data from a database.

D. Utilize standard Java API (Application Programmer Interface) classes and interfaces.

E. Implement type-casting.

F. Control program flow.

1. Implement selection statements.

a. Write code with if, else and else-if statements.

b. Use switch statements.

c. Write nested selection statements.

2. Implement repetition statements.

a. Write while, for and do loops.

b. Create nested loops.

c. Analyze break and continue semantics.

G. Trap errors using selection, repetition or exception handling.

IV. Methods

A. Define and call methods with void and non-void return values.

B. Implement static methods and instance methods.

C. Implement primitive value and reference value parameters.

D. Differentiate between actual and formal parameters.

E. Analyze and write elementary recursive code.

F. Analyze variable scope and lifetime.

G. Implement static variables and instance variables.

H. Write code that utilizes the “this” and “super” keywords.

I. Write code that utilizes method chaining.

J. Write code that utilizes overloaded methods.

K. Write code that utilizes methods from standard Java classes.

V. Fundamental Data Structures and Algorithms

A. Use standard Java data structures.

1. Use the String class.

2. Use the Array List class.

B. Implement single-dimensional arrays.

1. Implement an array of primitive data.

2. Implement an array of objects.

C. Implement two-dimensional arrays and multi-dimensional arrays.

D. Implement dynamic arrays.

1. Use new to acquire memory at run-time.

2. Declare reference variables.

E. Search arrays.

1. Implement sequential search.

2. Implement binary search.

F. Sort arrays.

1. Sort data using bubble sort.

2. Sort data using selection sort.

3. Sort data using insertion sort.

VI. Object-oriented Programming

A. Implement encapsulation and data abstraction by creating user-defined classes.

B. Differentiate between private, protected and public access modifiers.

C. Differentiate between static and non-static method and data modifiers.

D. Write accesssors, mutators and other member methods that process member data.

E. Write code that utilizes objects.

F. Implement composition.

G. Implement inheritance.

H. Implement polymorphism.

I. Implement exception handling.

J. Utilize wrapper classes.

K. Implement object interaction.

VII. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.

VIII. Professional Development Environment

A. Write code using a professional, integrated development environment (IDE).

B. Utilize key editor features.

C. Debug code using the integrated debugger.

D. Import and use the standard library.

Content Outline and Competencies:

I. Introduction
   A. Determine whether a solution is possible in a variety of
circumstances
   B. Count the number of solutions in a variety of circumstances
   C. Optimize a solution in a variety of circumstances
   D. Create PERT charts
   E. Find the critical path for a PERT chart

II. Sets
   A. Define a set and related properties
   B. Use operations with sets
   C. Use Venn Diagrams  with sets
   D. Use DeMorgan's Law
   E. Use the Cartesian Product

III. Equivalence Relations
   A. Define an equivalence relation
   B. Find if a relation has the reflexive property
   C. Find if a relation has the symmetic property
   D. Find if a relation has the transitive property
   E. Define and use partitions

IV. Congruence Classes
   A. Define a congruence class and related properties
   B. Do arithmetic operations using congruence classes

V. Functions
   A. Define a function and related properties
   B. Define one-to-one and related properties
   C. Define onto and related properties
   D. Define composition and related properties

VI.   Define and use the concepts of Mathematics Induction

VII. Graphs
   A. Define a graph and related properties
   B. Define a matrix and related properties
   C. Add matrices
   D. Subtract matrices
   E. Do scalar multiplication
   F. Do matrix multiplication
   G. Represent a graph as a graph, an adjacency list, and a matrix
   H. Change from any representation of a graph to another form
   I. Define and use the concept of isomorphisms
   J. Define a path and related properties for a graph
   K. Define a circuit and related properties for a graph
   L. Find Euler paths and circuits for a graph
   M. Find Hamiltonian paths and cycles for a graph
   N. Find the shortest path between any two points in a graph
   O. Color a map
   P. Find the graph of a map
   Q. Define a digraph and related properties
   R. Represent a digraph as a graph, an adjacency list, and a matrix
   S. Change the representation of a digraph from any representation of a
graph to another form
   T. Find the Euler paths and circuits for a digraph
   U. Find Hamiltonian paths and cycles for a digraph

VIII. Trees
   A. Define a tree and related properties
   B. Create a spanning tree for a graph
   C. Create a minimum spanning tree for a graph
   D. Create a maximum spanning tree for a graph
   E. Create a depth-first search spanning tree for a graph
   F. Create a breadth-first search spanning tree for a graph
   G. Define a rooted tree and related properties
   H. Define a binary tree and related properties
   I. Create an expression tree for a preorder, postorder, and inorder
expression
   J. Evaluate a preorder, postorder, and inorder expression
   K. From a tree, write the preorder, postorder, and inorder expression
   L. Develop an optimal tree using Huffman Code
   M. Develop and use a binary search tree

IX. Matching Problems
   A. Use systems of distinct representations to solve a variety of
problems
   B. Apply the algorithms of maximal independent sets to solve a variety
of problems

X. Network Flows
   A. Define a transportation network and related properties
   B. Maximize a transportation network
   C. Find a cut for an optimal transportation network 

XI. Counting Techniques
   A. Use the product rule
   B. Use the sum rule
   C. Use the Pigeonhole Principle
   D. Use the notation for permutations and combinations
   E. Use combinations
   F. Use permutations
   G. Use the principle of inclusion-exclusion

XII. Combinatorial Circuits
   A. Define AND, OR, and NOT gates and their related properties
   B. Use logical gates to create circuits
   C. Find the Boolean expression of a circuit
   D. Find the truth table for a Boolean expression
   E. Use Karnaugh maps to optimize a circuit or a logical expression

A minimum of 4 examinations            at least 60%
A minimum of 10 quizzes                at least 10%
A minimum of 10 homework assignments   at least 10%
                                               100%
Grade Criteria:
A = 90%
B = 80%     
C = 70%     
D = 60%     
F = less than 60%

Content Outline and Competencies:

Content Outline and Competencies:

I. Use fundamental mathematical tools
   A. Use logic
   B. Use truth tables
   C. Use propositional equivalences
   D. Use predicates and quantifiers
   E. Use sets
   F. Use Venn Diagrams
   G. Apply set operations
   H. Use power sets and cartesian products
   I. Use functions and their characteristics
   J. Use sequences and summations
   K. Use integer/mod arithmetic
   L. Use matrices
   M. Apply matrix operations

II. Do mathematical proofs
   A. Do proofs with truth tables
   B. Do proofs using mathematical induction
   C. Use rules of inference

III. Recursion
   A. Develop recursive algorithms
   B. Develop recursive functions
   C. Evaluate recursive definitions

IV. Counting
   A. Use the Sum Rule
   B. Use the Product Rule
   C. Use the Pigeonhole Principle
   D. Use Inclusion-Exclusion Principle
   E. Use Tree diagrams to solve appropriate counting problems
   F. Use Permutations
   G. Use Combinations
   H. Use discrete probability
   I. Use generalized permutations and combinations
   J. Use recurrence relations
   K. Solve recurrence relations
   L. Apply the inclusion-exclusion principle

V. Relations
   A. Use relations on a set
   B. Use the properties of relations
      1. reflexive
      2. irreflexive
      3. symmetric
      4. asymmetric
      5. antisymmetic
      6. transitive
   C. Combine relations
   D. Use n-ary relations
   E. Use elementary database principles
   F. Represent relations in matrix form
   G. Represent relations in digraph form
   H. Define equivalence relations
   I. Define partial orderings
   J. Use Hasse Diagrams to represent partial orderings

VI. Graph Theory
   A. Define graphs, digraphs, simple graphs, multigraphs, pseudographs
   B. Represent graphs as pictures
   C. Represent graphs in matrix form
   D. Use graph terminology
   E. Apply graph theory to applications
   F. Use adjacency and incidence matrices
   G. Use isomorphisms and their properties
   H. Use connectivity, paths and circuits
   I. Create Euler paths and circuits
   J. Create Hamilton paths and cycles
   K. Using Dijkstra's Algorithm, find the shortest path between points
   L. Use planar graphs and their properties
   M. Color maps, create graphs of maps, and use their properties

VII. Trees
   A. Define a tree and related vocabulary
   B. Use the properties of trees
   C. Create binary search trees
   D. Use trees for preorder, postorder, and inorder expressions
   E. Develop preorder, postorder, and inorder expressions
   F. Translate trees  into preorder, postorder, and inorder expressions
   G. Translate preorder, postorder, and inorder expressions to trees
   H. Use tree transversal methods
   I. Evaluate preorder, postorder, and inorder expressions
   J. Evaluate preorder, postorder, and inorder trees
   K. Define spanning trees
   L. Create minimum and maximum spanning trees of graphs
   M. Create depth-first and breadth-first spanning trees of graphs

VIII. Boolean Algebra
   A. Use Boolean expressions and operations
   B. Create a Truth Table from a Boolean expression
   C. Represent Boolean Expression as sums of products
   D. Define logic gates and related properties
   E. Create Boolean expressions from circuits
   F. Use logic gates to include OR, AND, NOT, NOR, and NAND
   G. Create circuits using OR, AND, NOT, NOR, and NAND gates
   H. Use Karnaugh Maps to minimize circuits and Boolean expressions
   I. Use Quine-McCluskey method to minimize circuits and Boolean
expressions

IX. Grammars
   A. Define grammars and related properties
   B. Use Phrase-Structure grammars
   C. Use finite-state machines 

A minimum of 3 examinations            50%
A minimum of 25 homework assignments   41.66%
A minimum of 5 quizzes                  8.33%
                                      100%
Grade Criteria:
A = 90%
B = 80%     
C = 70%     
D = 60%     
F = less than 60%

Content Outline and Competencies:

Content Outline and Competencies:

I.  Software Development

A. Identify C++ features needed to solve problems in C++.

B. Define the problem and identify the classes.

C. Develop a solution.

D. Code the solution.

E. Test the solution.

II  Encapsulation and Data Abstraction

A. Apply the C++ syntax to define classes.

B. Use the string class and the vector template classes.

C. Create copy constructors.

D. Create friend functions.

E. Create overloaded operators including the >>, << and = operators.

F. Implement class composition.

G. Describe and create constructors and destructors.

H. Describe use of the “this” pointer.

I. Implement classes that contain arrays of objects.

J. Compare static and instance data members in a class.

K. Compare private and public access specifiers.

III. Advanced Programming Topics

A. Establish pointers to manage dynamic memory.

1. Use new and delete operators.

2. Declare dynamic memory arrays.

3. Define and use pointers to objects.

4. Define objects containing pointers.

B. Create recursive functions.

C. Organize projects into multiple files.

D. Handle exceptions caused by unusual or error conditions during program execution.

E.  Describe and use the C++ I/O system.

F.  Create templates to develop data independent classes.

IV. Inheritance

A. Explain how inheritance can be used to develop new classes.

B. Explain the “is-a” and the “has-a” relationships between classes.

C. Describe and use constructors and destructors for inherited classes.

D. Define the base class.

E. Use inherited classes.

F. Create overloaded, inherited functions.

V. Polymorphism

A. Explain how polymorphism is used to solve programming problems.

B. Create virtual functions.

C. Create abstract classes using pure virtual functions.

D.  Explain static binding and dynamic binding.

VI. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.

Content Outline and Competencies:

I. Object-Oriented Programming and Frameworks

A. Discuss the history and objectives of C# and .NET.

B. Explain and utilize the characteristics of object-oriented design.

C. Utilize Visual Studio and explore an associated framework.

II. Object-Oriented Windows Solutions

A. Discuss key elements of graphical user interfaces (GUI).

B. Discuss issues related to GUI design.

C. Design, develop, debug and execute GUI desktop solutions.

D. Employ common GUI controls.

III. Event-Driven Programming

A. Implement delegates.

B. Implement event handlers.

C. Apply combo box and list box classes in C# programs.

D. Apply menus, tab controls, radio buttons and check box classes in C# programs.

IV. Advanced Object-Oriented Programming

A. Utilize abstraction, encapsulation, inheritance and polymorphism in object-oriented design.

B. Explain the difference between composition and inheritance.

C. Discuss why polymorphism is a common goal in .NET.

D. Discuss multi-tier applications and component-based development.

E. Utilize abstract and partial classes.

F. Implement interfaces.

G. Implement generics

V. Error Handling

A. Explain exception classes.

B. Employ standard exceptions and create custom exceptions.

C. Employ exception handling techniques including catching and throwing exceptions and using try, catch and finally blocks.

D. Experiment with the numerous types of errors and exceptions and develop advanced techniques for debugging.

E. Employ the debugger to find run-time errors.

VI. File Input and Output

A. Utilize the System.IO namespace classes.

B. Employ File and Directory classes.

C. Employ FileInfo and DirectoryInfo classes.

D. Apply stream classes to read and write data from text files in C# programs.

E. Read and write binary files.

VII. Data Structures and Data Access with ASP.NET, SQL, and LINQ

A. Discuss common data structures such as lists, stacks, queues and trees.

B. Utilize generics with a data structure to solve an applications problem.

C. Discuss data access technologies.

D. Employ DataReader, DataSet and DataAdapter classes.

E. Employ SQL to query databases.

F. Utilize visual development tools for data access.

G. Explain the use of LINQ.

VIII. Web Solutions

A. Compare and contrast Windows versus web development.

B. Explain and employ ASP.NET.

C. Utilize a variety of web controls.

D. Explain web services and their role in distributed applications.

E. Discuss issues related to the development of mobile applications.

IX. C# Frameworks

A. Discuss frameworks and software development kits (SDKs) - what they are and when they are used.

B. Employ a sample framework.

C. Develop and use multimedia classes (e.g., images and sounds).

D. Discuss applications that employ additional devices and hardware.

E. Create an application using a sample framework or SDK.

Content Outline and Competencies:

I. Advanced Object-Oriented Code

A. Implement inheritance.

B. Implement polymorphism, virtual methods and late binding.

C. Implement class and function templates.

D. Write code with classes from the Standard Template Library.

E. Implement class composition.

F. Create user-defined exception objects.

G. Implement friend classes and functions.

H. Implement overloaded operators.

II. Advanced Programming Topics

A. Manage indexing, pointers and multiple levels of indirect addressing.

B. Manage dynamic memory.

C. Write recursive programs.

D. Organize projects into multiple files.

E. Handle exceptions.

F. Pass function pointers.

G. Implement backtracking.

H. Examine and create recursive grammars and languages.

I. Implement prefix and postfix expressions.

III. Fundamental Data Structures

A. Analyze code implementing linked lists, dummy head nodes, circular linked lists and doubly linked lists.

B. Analyze code implementing stacks.

C. Analyze code implementing queues.

D. Analyze code implementing trees and associated traversals.

E. Analyze code implementing dictionaries.

F. Analyze code implementing priority queues.

G. Analyze code implementing heaps.

H. Analyze code implementing hash tables.

I. Create applications utilizing fundamental data structures.

IV. Advanced Algorithms

A. Review data sorting with selection, bubble and insertion sort.

B. Sort data with merge sort, quick sort, radix sort and heap sort.

C. Analyze algorithmic efficiency.

V. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.

Content Outline and Competencies:

I. Advanced Object-Oriented Code

A. Implement inheritance.

B. Implement polymorphism, virtual methods and late binding.

C. Implement generic classes and interfaces.

D. Write code with classes from the Java Library.

E. Implement class composition.

F. Create user-defined exception objects.

II. Advanced Programming Topics

A. Write recursive programs.

B. Organize projects into packages and multiple files.

C. Handle exceptions.

D. Examine and create recursive grammars and languages.

E. Implement prefix and postfix expressions.

F. Input and output data using advanced input/output capabilities.

III. Fundamental Data Structures

A. Analyze code implementing linked lists, dummy head nodes, circular linked lists and doubly linked lists.

B. Analyze code implementing stacks.

C. Analyze code implementing queues.

D. Analyze code implementing trees and associated traversals.

E. Analyze code implementing priority queues.

F. Analyze code implementing heaps.

G. Analyze code implementing hash tables.

H. Create applications utilizing fundamental data structures.

IV. Advanced Algorithms

A. Review data sorting with selection, bubble and insertion sort.

B. Sort data with merge sort, quick sort and heap sort.

C. Review linear and binary searching.

D. Analyze algorithmic efficiency.

V. Code Standards

A. Create descriptive identifiers according to language naming conventions.

B. Write structured and readable code.

C. Create documentation.