Learning Targets

Learning Targets

About Learning:

  • Know it well
  • Remember it always
  • Use it readily 

Learning targets are provided so that both students and parents understand exactly what a student should understand and be able to do after completing each unit in our various courses.

Computer Concepts

Computer Science 1

Computer Science 2

AP Computer Science

 

Learning Targets
Computer Concepts
After completing Computer Concepts, the student will be able to independently demonstrate understanding of the following learning targets and be able to apply them:
Introductory Unit
1.      Understand general computer terminology.
2.      Describe with words and graphically how a computer works (general design, microprocessor, and memory).
3.      Analyze basic computer usage in school setting.
4.      Discuss the role of an operating system.
5.      Recognize need for Internet security and personal responsibilities when using computers (passwords, viruses, adware, spyware, phishing, and security software).
Word Unit
1.      Understand terminology unique to Word.
2.      Use basic editing (cut/copy/paste) and identify/select appropriate fonts.
3.      Adjust character formatting such as bold, italics, underlining, font effects and be able to use the format painter.
4.      Adjust the following paragraph formats:
·        Spacing (within, before and after).
·        Bulleted and numbered lists (standard and custom).
·        Justification (alignment).
·        Indentation (left, right, first line, hanging and negative).
·        Tabs (left, right, center, decimal, and bar, with or without leaders).
·        Borders and shading.
·        Drop Caps.
5.      Create, edit, sort and format tables (borders, shading, positioning, sizing).
6.      Apply sections to create multiple column documents with breaks as appropriate.
7.      Insert, position, size and edit graphics.
8.      Insert, position, size and format text boxes.
9.      Apply and manage symbols, fields, footnotes, headers and footers.
Excel Unit
1.      Use terminology unique to Excel.
2.      Create new spreadsheets-inserting/deleting rows, adjusting row/column size and sorting.
3.      Format a spreadsheet by use of:
·        Number and date styles, decimal places.
·        Format painter.
·        Merge and center.
·        Borders and shading.
4.      Use simple formulas (+,-,*,/,^) consistent with order of operations and correct cell references.
5.      Use simple functions (Sum, Average, Min, Max, Count, CountA, Median) over appropriate range of cells.
6.      Apply relative and absolute cell references as appropriate.
7.      Create spreadsheets to analyze investing or borrowing money:
·        Manually calculate interest, payments for various scenarios including the use of compound interest.
·        Use spreadsheets to automatically calculate interest and payments.
·        Use the PMT function to calculate payments for various scenarios.
8.      Use the advanced functions of IF and VLOOKUP with spreadsheets for topics such as sales, taxes and payroll.
9.      Create charts based on spreadsheet data:
·        Select the most appropriate chart type for the situation.
·        Edit charts to more clearly present the information.
·        Add drawings and text annotations to enhance a chart.
Access Unit
1.      Understand terminology unique to databases.
2.      Apply filters to select and sort data to analyze data.
3.      Create queries to:
·        Select and sort data for analysis, using wild cards as needed.
·        Calculate fields to generate new information.
4.      Use the report wizard to create standard, grouped and label style reports:
·        Edit reports to improve appearance.
·        Add summary information.
5.      Use the form wizard to develop standard forms.
·        Edit a form to improve appearance.
·        Use a form to enter or access information.
PowerPoint Unit
1.      Understand terminology unique to PowerPoint.
2.      Create presentations using templates, images, standard and custom animation and which include various objects (charts, organizational diagrams and tables).
3.      Use PowerPoint to deliver a presentation on a computer related topic.
 
 
 
LEARNING TARGETS
Computer Science 1
After completing Computer Science 1, the student will be able to independently demonstrate understanding of the following learning targets and be able to apply them:
Introductory Unit
1.      Understand general computer terminology.
2.      Describe with words and graphically how a computer works (general design, microprocessor, and memory).
3.      Analyze basic computer usage in our school setting.
4.      Discuss the role of an operating system, and DOS limitations.
5.      Recognize the need for Internet security and personal responsibilities when using computers (passwords, viruses, adware, spyware, phishing, and security software).
6.      Use basic flow charting symbols and concepts.
Introduction to Programming Unit
1.      Use the PRINT statement to print literals, numeric calculations, and variables along with semi-colon and comma syntax.
2.      Understand the concept of variables and rules pertaining to their use
3.      Use the LET statement to perform calculations.
4.      Use the INPUT statement to obtain simple numeric values.
5.      Understand order of operations and scientific notation.
6.      Use loops to count, sum, and average values (infinite loops, pre and post checked loops).
7.      Use flow charts to plan and explain loops.
8.      Use the math functions: ABS, SQR, and INT.
Programming Basics Unit
1.      Use the INT function to break up numbers, determine divisibility, calculate a quotient and remainder, and to round numbers.
2.      Use the IF-THEN-ELSE statement to make decisions in programs.
3.      Use the READ/DATA statements to assign values to variables.
4.      Master the use of loops to count, sum, and average values (infinite loops, pre and post checked loops).
Random Numbers and Graphics Unit
1.      Use the RND function to calculate random decimal and integer values in a specified range.
2.      Use the RND function in simulations involving coins, dice, cards, etc.
3.      Use the graphics commands: PSET, LINE, CIRCLE, and PAINT to create graphical images including movement.
4.      Use subroutines to simplify drawing of complex objects.
String Unit
1.      Understand the difference between numeric and string variables, and when it is appropriate to use each.
2.      Use the basic string functions LEFT$, RIGHT$, MID$ and LEN to manipulate string variables.
3.      Use the advanced string functions VAL/STR$, ASC/STR$, LTRIM$/RTRIM$ to manipulate string and numeric data.
Introduction to Arrays Unit
1.      Understand the purpose of arrays and the terminology associated with them.
2.      Use arrays to store data, search for specific items, and count events.
3.      Use flow charts to plan and explain array usage in a program.
4.      Understand the use of arrays to sort data and the different types of sorts available.
Using Arrays Unit
1.      Use the Linear and Binary searches to find information in an array.
2.      Understand the advantages/disadvantages of each search, when to use them, and be able to calculate the number of comparisons required when using them.
3.      Use the Bubble, Shuttle Interchange, and Shell-Metzner sorts to sort an array.
4.      Understand the advantages/disadvantages of each sort, when to use them, and be able to calculate the amount of time required to use each.
5.      Use arrays to tally events.
 
 
 
LEARNING TARGETS
Computer Science 2
After completing Computer Science 2, the student will be able to independently demonstrate understanding of the following learning targets and be able to apply them:
Multi-dimensional Arrays Unit
1.      Understand the need for and terminology related to multi-dimensional arrays.
2.      Be able to write programs to input & output 2-D arrays.
3.      Be able to write programs to manipulate individual rows, individual columns, and an entire 2-D array.
4.      Be able to write programs to sort and search a 2-D array.
Sequential Text Files Unit
1.      Understand the need for and terminology related to sequential access text files.
2.       Be able to write a program that creates a text file with a specified format, including multiple fields per record.
3.      Be able to write a program that accesses a text file that includes multiple fields per record using the number of records, trailer values, or EOF syntax.
4.      Be able to write a program that combines or modifies multiple text files.
5.      Be able to write a program that searches and/or sorts a text file.
Sub-Procedures Unit
1.      Understand the need for sub-procedures, and the differences between sub-procedures and sub-routines.
2.      Be able to write a program that passes parameters to and from a sub-procedure.
3.      Understand and be able to use the menu routine developed in class, including the BASIC statements: CONST, INKEY$, and SELECT CASE.
4.      Be able to write a program using sub-procedures to sort and/or search arrays, produce various graphical outputs, and decapitalize strings.
Random Access Text File Unit
1.      Understand the differences between random access and sequential access text files, and the advantages/disadvantages of each.
2.      Be able to write a program utilizing a user defined variable type.
3.      Be able to create and access random access text files containing user defined variable data.
4.      Be able to sort and search arrays containing user defined variable data.
5.      Understand and be able to use the line input routine developed in class.
Event Driven Programming Unit
1.      Understand the difference between event driven programming and standard programming.
2.      Be able to write programs that handle the trapping of timed events, key presses, and music.
3.      Be able to write programs that trap user errors and respond in an appropriate manner.
Assembly Language Basics Unit
1.      Understand numbers expressed in base 2, 8, 10 and 16.
2.      Be able to convert numbers between any two specified bases.
3.      Be able to add and subtract numbers expressed in binary and hexadecimal form.
4.      Be able to express both positive and negative numbers in binary form.
5.      Be able to explain how a computer adds signed binary numbers including the use of the carry and overflow.
Assembly Language Programming Unit
1.      Understand the basic organization of a computer system (microprocessor, memory, ROM routines, input and output).
2.      Be able to write programs in assembly language that utilize the math operations of addition, subtraction, multiplication and division.
3.      Be able to write programs in assembly language that utilize loops.
4.      Be able to write programs in assembly language that use shift and rotate commands to perform bit manipulation and specialized multiplication and division.
5.      Be able to write programs that utilize indexing to manipulate string or array data.
 
 
LEARNING TARGETS
AP Computer Science
After completing AP Computer Science, the student will be able to independently demonstrate understanding of the following learning targets and be able to apply them:
Introductory Unit
1.      Understand the basic concepts of Object-Oriented Programming (class, object, method/message and signatures, encapsulation, information hiding, inheritance, abstraction).
2.      Understand the differences between Java interpreted vs. compiled code, the Java Virtual Machine and Byte Code.
3.      Be able to use the PrinterIO package, and understand the concept of importing packages.
4.      Understand the main() method and its significance as an interface with operating system.
5.      Understand appropriate programming style (capitalization consistency, indentation and bracket placement, comments).
6.      Be able to use primitive data types (int, double, char, String, boolean) in a program.
7.      Be able to use arithmetic expressions (binary vs. unary operators, order of operations) in a program.
8.      Understand what happens when exceeding the range of ints or doubles.
9.      Understand how Java handles mixed mode arithmetic and automatic type conversion, and type casting.
10. Be able to use simple string expressions and methods.
Standard Programming Techniques Unit
1.      Be able to write programs using increment/decrement and combination assignment operators.
2.      Be able to write programs using the following functions from the Math class (abs, pow, round, max, min, sqrt).
3.      Be able to write programs using Math.random() to generate random integers and doubles.
4.      Be able to write programs using if and if-else statements along with the Boolean expressions (== and != and !).
5.      Be able to write programs using the FOR loop, the WHILE loop, and the DO WHILE loop.
6.      Be able to identify which loop is most appropriate for specific situations.
7.      Be able to use the Monte Carlo Technique to experimentally determine a probability.
8.      Understand the problems associated comparing floating point numbers.
Object Oriented Programming Unit
1.      Be able to create and use classes and objects (constructors, state of an object, classes, objects and methods, instance variables (state variables), constructors, accessors, mutators).
2.      Be able to use the standard methods toString and equals in a program.
3.      Understand the scope and lifetime of variables.
4.      Understand the difference between formal and actual parameters.
5.      Understand the difference between primitive types, objects, and strings.
6.      Be able to pass parameters to methods and understand the difference between passing parameters by value or reference.
7.      Understand the difference between implicit and explicit parameters, and be able to use the this notation.
Loops, Logic and Arrays Unit
1.      Be able to use logical expressions (AND / OR / NOT) in a program, and use DeMorgan’s law to simplify logical expressions.
2.      Understand Java’s use short-circuit evaluation.
3.      Be able to write a program that uses the switch statement.
4.      Be able to create test data to determine if a program is executing properly.
5.      Be able to write programs that utilize various types of nested loops.
6.      Be able to utilize the String methods of trim, and equals.
7.      Be able to write programs that utilize user-defined functions.
8.      Be able to write programs and functions that use Java arrays.
9.      Be able to write programs that use arrays to tally items.
10. Be able to write programs using parallel arrays.
11. Be able to write programs using two-dimensional arrays.
12. Understand parameter passing as it pertains to arrays.
13. Be able to write programs using arrays of Objects.
14. Be able to write programs using static variables and methods, as appropriate.
Inheritance, Abstract classes & Interfaces Unit
1.      Be able to write programs utilizing Java interfaces.
2.      Be able to write programs utilizing Java inheritance.
3.      Understand the similarities and differences between interfaces and inheritance.
4.      Understand the differences between abstract classes and concrete classes and when to use each.
5.      Understand the acceptable classes for parameters and return values.
Exceptions, Text Files & String Methods Unit
1.      Understand the need for, and the terminology related to, sequential access text files.
2.      Be able to write programs that can access the contents of a text file and/or create a text file.
3.      Understand the concept of exceptions, handling exceptions including multiple types of exceptions.
4.      Understand the difference between equality and object identity (== vs. equals), and be able to write a simple equals method.
5.      Be able to write a program that uses the String method substring, and other advanced String methods as required.


Sorting, Searching, Arrays & ArrayList Unit
1.      Understand the how various searches work (linear and binary), and when it is appropriate to use each.
2.      Be able to write a program that uses the linear search to find primitive data types, Strings, and objects.
3.      Be able to write a program that uses the binary search to find primitive data types, Strings, and objects.
4.      Understand the how various sorts work (selection, exchange and insertion), and when it is appropriate to use each.
5.      Be able to write programs using various sorting techniques to sort primitive data types, Strings, and objects.
6.      Be able to use the ArrayList class to implement, sort and search arrays.
Recursion, Analysis of Algorithms, Big-O Unit
1.      Understand the differences between recursion and iteration, and the advantages & disadvantages of each.
2.      Be able to write the binary search both iteratively and recursively.
3.      Be able to solve the Towers of Hanoi problem recursively.
4.      Understand the standard big-O expressions of n^3, n^2, n * log(n)^2, n * Log(n) and be able to give an example of an algorithm for each.
5.      Understand the need to analyze algorithm efficiency and be able to express efficiency using big-O notation.
6.      Understand how the quick sort works and be able to use it in a program.
Sets & Linked Lists Unit
1.      Be able to define and discuss concept of an ADT.
2.      Be able to define and discuss concept of a set, set operations (union, intersection, difference, subset), and the Java interface (add, contains, remove, size(), iterator).
3.      Be able to write a program using sets implemented by java.util.HashSet and java.util.TreeSet.
4.      Be able to use an iterator to access a set, understand the simple AP iterator interface (hasNext, next, remove).
5.      Be able to define and discuss the concept of a linked list.
6.      Be able to write a program using linked lists implemented with the simple AP interface, by java.util.ArrayList, and by java.util.LinkedList.
7.      Be able to implement a linked list using user-constructed nodes.
Linked Lists & Stacks Unit
1.      Be able to write programs using doubly linked lists.
2.      Understand the concept of a stack, LIFO data structure, AP interface, implemented by ArrayStack and ListStack.
3.      Be able to write programs using a stack implemented using an ArrayList, LinkedList, or user-created nodes.
4.      Understand the difference between using an ArrayList to implement a stack and simply extending an ArrayList to implement a stack.
Queues and Maps Unit
1.      Understand the concept of a queue, the AP Interface, and be able to list examples of queue uses.
2.      Be able to write a program that implements a queue using a linked list.
3.      Understand the concept of a map, the AP interface, and be able to list examples of map uses.
4.      Be able to write a program that uses hashMap or treeMap to implement a map.
5.      Be able to use an iterator to access information in a map.
Tree Unit
1.      Be able to define and discuss binary trees (binary search tree, in-order, pre-order, post-order, parental pointer tree, other non-binary trees).
2.      Be able to write a program that implements a binary search tree.
3.      Be able to write a program that extends the tree class by adding find/search (member / non-member, recursive / non-recursive versions).
4.      Write a sorted set class using the Tree Class.
Hashing, Heaps, and Priority Queues Unit
1.      Be able to discuss the concept of hashing.
2.      Be able to write a hashCode() method for Strings and other class objects.
3.      Be able to define heap terms and discuss the appropriate uses of heaps.
4.      Be able to describe the heap sort algorithm and write a program that uses it.
5.      Be able to write a program that implements a heap.
6.      Be able to define a priority queue and discuss the appropriate uses of priority queues.
7.      Be able to write a program that implements a priority queue.
AP Case Study Unit
1.      Be able to install and run the GridWorld case study project, and be able to discuss the purposes of the simulation.
2.      Be able to write a program that extends the bug class in order to implement specific bug behaviors.
3.      Be able to write a program that uses the GridWorld Location, Grid, and Actor classes.
4.      Be able to describe the merge sort algorithm and write a program that uses it.
5.      Be able to write a program that extends the Critter class in order to implement specific behaviors.
6.      Be able to write a program that uses the AbstractGrid, BoundedGrid, and UnboundedGrid classes of the case study to implement a specified environment.
 
 

 

Adjust Font Size: A   A   A   A   A   A