APCS A Topic Outline Correlation and Syllabus

Document Sample
APCS A Topic Outline Correlation and Syllabus Powered By Docstoc
					AP® Computer Science A
Syllabus          [C2]


Course Resources                                                                                  C2 - The course
A Guide to Programming Using Java, Second Edition                                                 includes all of the
                                                                                                  topics listed in the
Beth Brown, 2007, Lawrenceville Press (Referred to as Text)                                       “Computer Science
                                                                                                  A” column of the
A Guide to Programming Using Java, Second Edition Teacher Resource Materials                      Topic Outline in the
                                                                                                  AP Computer
Beth Brown, 2007, Lawrenceville Press (Referred to as TRM)                                        Science Course
                                                                                                  Description.
Supplements from http://www.Lpdatafiles.com (Referred to as Online Supplement)

AP® GridWorld Case Study


                                                                            Resources and
 Unit               Topic and                      Projects and
                                                                             Supporting
(week)             Topic Outline                   Assessment
                                                                              Materials
 Unit 1    An Introduction to                   Introduction to class     Text pages 1-34
(week 1)   Computers [C8] [C9]                   and computer center        (Chapter 1)           C8 – The course
                                                                                                  teaches students to
            Single-user systems (p 1)          Research the              TRM Chapter 1
                                                                                                  identify the major
            Peripherals (p 1)                   classroom computer         Lesson 1              hardware and
                                                 network (p 32)            TRM Chapter 1         software
            Processors (p 2)                                                                     components of a
                                                Research ergonomics        Lesson 2
            Primary and secondary                                                                computer system,
                                                 and Carpal Tunnel         TRM Ch01 Lesson 1     their relationship to
             memory (p 2)
                                                 Syndrome (p 33)            Worksheet 1           one another, and
            Operating systems (p 2-4)                                                            the roles of these
                                                Explore emerging           classroom networks    components within
            Language                            technologies and their    TRM Ch01 Lesson 1     the system.
             translators/compilers (p 5-6)       impact on individuals      Worksheet 3 number
            Networks (p 6-9)                    and businesses (p 34)      system conversions
            Representations of numbers in      Review Questions 1-       TRM Ch01 Lesson 2
             different bases (p 9-10)            23, 43-48 (p 29-30)        Worksheet 2
            Limitations of finite              Test 1                     protecting computer
             representations (e.g., integer                                 systems               C9 – The course
             bounds, imprecision of                                        TRM Ch01 Lesson 2     teaches students to
             floating-point representations,                                Worksheet 4           recognize the ethical
                                                                                                  and social
             and round-off error) (p 10-11)                                 ergonomics            implications of
            Privacy (p 18-20)                                             Online Supplement     computer use.
            Legal issues and intellectual                                  Operating Systems
             property (p 21)
            System reliability (p 22)
            Social and ethical
             ramifications of computer use
             (p 22)




                                                                                                                          1
 Unit 2    Introducing Java [C3] [C6]           BinaryNumbers              Text pages 59-76      C3 – The course
(week 2)    Introduce the concept of            (reinforce the              (Chapter 3)           teaches students to
                                                 representations of                                design and
             object-oriented development                                    TRM Chapter 3         implement
             (p 59)                              numbers in different        Lesson 1              computer-based
                                                 bases) (p 75)                                     solutions to
            Introduce the concept of                                       TRM Chapter 3
                                                RockPaperScissors-                                problems in a variety
             encapsulation (p 59)                                            Lesson 2              of application areas.
                                                 Rules (p 73)
            Introduce identifying reusable
             components from existing           JavaTerminology (p
             code using classes and class        74)
             libraries (p 59-60)                Simple applications to                            C4 – The course
                                                                                                   teaches students to
            Sequential programming              reinforce concepts                                use and implement
             constructs (p 61)                   (Reviews p 59-65)                                 commonly used
                                                Critical Thinking 1-16                            algorithms and data
            Virtual machines (p 62)                                                               structures.
                                                 (p 71)
            Console output
             (System.out.print/println) (p      Test 2
             63)
                                                                                                   C5 – The course
                                                                                                   teaches students to
                                                                                                   develop and select
 Unit 3    Variables and Constants [C3]         CollegeCalculator (p       Text pages 77-104     appropriate
(weeks     [C4] [C5] [C6]                        99)                         (Chapter 4)           algorithms and data
 3, 4)      Primitive types vs. objects (p     JavaTerminology            TRM Chapter 4         structures to solve
             79-80)                                                                                problems.
                                                 (modify existing code)      Lesson 1
            Variable declarations (p 77-        (p 99)                     TRM Chapter 4
             80)                                GallonConverter (p          Lesson 2
            Classes (abstract data type)        102)                       TRM Ch04 Primitive    C6 – The course
             (p 80)                             SimpleInterest (p           Data Types in Java    teaches students to
                                                 103)                        PDF                   code fluently in an
            Constant declarations (p 87)
                                                                                                   object-oriented
            Simple data types (int,            Project (time spent        TRM Ch04 Syntax and   paradigm using the
             boolean, double) (p 77-79)          designing, coding,          Logic Errors PDF      programming
                                                                                                   language Java. The
            Identify reusable components        debugging, and             TRM Ch04 Java         course teaches
             from existing code using            testing an application)     Packages PDF          students to use
             classes and class libraries (p      (p 102)                                           standard Java library
                                                                            TRM Ch04 Lesson 1     classes from the AP
             80-81)                             Simple applications to      Worksheet 1 using     Java subset
            Categorize errors: compile-         reinforce concepts          variables             delineated in
             time, run-time, logic (p 88-89)     (Reviews p 79-88)                                 Appendixes A and B
                                                                            TRM Ch04 Lesson 2     of the AP Computer
            Identify and correct errors (p     BirthdayGame Case           Worksheet 1 numeric   Science Course
             88-89)                              Study (p 90-93)             expressions           Description.

            Understand run-time                Critical Thinking 1-16
             exceptions (p 89)                   (p 97-98)
            Read and understand a              Test 3
             problem description, purpose,
             and goals (p 90-93)




                                                                                                                         2
 Unit 4   Conditional Control                 GuessingGame (p           Text pages 105-130    C3 – The course
(weeks    Structures [C3] [C4] [C5] [C6]       125)                       (Chapter 5)           teaches students to
 5, 6)                                                                                          design and
           Conditional control structures    QuadraticEquation (p      TRM Chapter 5         implement
            (105-108)                          126)                       Lesson 1              computer-based
           The Math class                    CarPayment (p 127)        TRM Chapter 5         solutions to
                                                                                                problems in a variety
            (Math.random()) (p 109-111)       Simple applications to     Lesson 2              of application areas.
           The Math class (Math.abs(),        reinforce concepts        TRM Ch05 Lesson 1
            Math.pow(), Math.sqrt()) (p        (Reviews p 106-113)        Worksheet 1 Boolean
            113)                              RPS Case Study (p          logic
           Understand and modify              114-118)                  TRM Ch05 Lesson 2
            existing code (p 118)             Modify existing RPS        Worksheet 2
                                                                                                C4 – The course
                                               code (p 118)               DeMorgan’s Laws       teaches students to
                                              Critical Thinking 1-8     TRM Ch05 Java         use and implement
                                                                                                commonly used
                                               (p 121)                    Operator Precedence
                                                                                                algorithms and data
                                                                          Rules PDF             structures.
                                              Test 4


 Unit 5   Loop Structures and Strings         PrimeNumber (p 150)       Text pages 131-156
(weeks    [C3] [C4] [C5] [C6]                                             (Chapter 6)
                                              GuessingGame
 7, 8)     Iteration (p 131, 135)             (introduce the            TRM Chapter 6         C5 – The course
                                                                                                teaches students to
           Identify and correct errors (p     concept of binary          Lesson 1              develop and select
            132)                               search) (p 151)           TRM Chapter 6         appropriate
                                                                                                algorithms and data
           Employ techniques such as         Hailstone (p 154)          Lesson 2
                                                                                                structures to solve
            using a debugger, adding          Chaos (p 154)             TRM Ch06 The          problems.
            extra output statements, or                                   JCreator Debugger
                                              CountVowels (p 156)
            hand-tracing code (p 136-                                     PDF
            137)                              Simple applications to                           C6 – The course
                                               reinforce concepts                               teaches students to
           The String class (p 138-141)
                                               (Reviews p 133-141)                              code fluently in an
                                                                                                object-oriented
                                              WordGuess Case                                   paradigm using the
                                               Study (p 141-146)                                programming
                                                                                                language Java. The
                                              Modify existing
                                                                                                course teaches
                                               WordGuess code (p                                students to use
                                               146)                                             standard Java library
                                                                                                classes from the AP
                                              Critical Thinking 1-14                           Java subset
                                               (p 149)                                          delineated in
                                              Test 5                                           Appendixes A and B
                                                                                                of the AP Computer
                                                                                                Science Course
                                                                                                Description.




                                                                                                                      3
 Unit 6   Methods [C3] [C4] [C5] [C6]          AddCoins (p 176)          Text pages 157-178
(weeks     Methods (p 157-160)                HiLo (p 177)               (Chapter 7)
 9, 10,                                                                   TRM Chapter 7
           Top-down development (p            Nim (p 178)
  11)                                                                      Lesson 1
            157)                               GuessingGame
           Procedural abstraction (p 157)      (modify) (p 178)          TRM Chapter 7
                                                                           Lesson 2
           Method declarations (p 159-        Simple applications to
            160)                                reinforce concepts        TRM Ch07 Lesson 1
                                                (Reviews p 160-165)        Worksheet 1 writing
           Parameter declarations (p
                                                                           methods
            160-161)                           GradeConverter Case
                                                Study (p 165-171)         TRM Ch07 Lesson 2
           Pre- and post-conditions (p
                                                                           Worksheet 1 base
            164-165)                           Modify existing
                                                                           conversion
           Assertions (p 164-165)              GradeConverter code
                                                (p 171)
           Identify boundary cases and
            generate appropriate test data     Critical Thinking 1-11
            (p 168)                             (p 174)
           Perform integration testing (p     Test 6
            170-171)


 Unit 7   Classes and Object-                  MySavings (p 207)         Text pages 179-210       C7 – The course
(weeks    Oriented Programming [C3]            DiceRollGame (p 208)       (Chapter 8)              teaches students to
12, 13,   [C4] [C5] [C6] [C7]                                                                       read and understand
                                               Nim2 (p 209)              TRM Chapter 8            a large program
14, 15)    Classes (p 179-185)                                            Lesson 1                 consisting of several
                                               Bowling (p 210)
           Apply data abstraction and                                    TRM Chapter 8            classes and
            encapsulation (p 179-182)          Simple applications to                              interacting objects,
                                                                           Lesson 2                 and enables
                                                reinforce concepts
           Design and implement a class                                  TRM Ch08 Lesson 2        students to read and
                                                (Reviews p 182-195)
            (p 180-182)                                                    Worksheet 2 code         understand the
                                               RPS2 Case Study (p                                  current AP Computer
           Apply functional                                               reusability              Science Case Study
                                                196-202)
            decomposition (p 180)                                         TRM Ch08 Lesson 2        posted on AP
                                               Modify existing RPS2                                Central.
           Choose appropriate data                                        Worksheet 3 testing a
                                                code (p 202)
            representation and algorithms                                  class in isolation and
            (p 179-185)                        Critical Thinking 1-15     integration testing
                                                (p 205-206)
           Class declarations (p 180)                                    TRM Ch08 Lesson 2
                                               Test 7                     Worksheet 4 using
           Encapsulation and information
            hiding (p 182)                                                 the keyword this to
                                                                           pass an object to a
           The Object class (p 185-186)
                                                                           method
           Introduce the concept of
            inheritance (p 186-187)
           Read and understand class
            specifications and
            relationships among the
            classes (has-a relationship) (p
            187)
           Object-oriented development
            (p 191-192)
           Identify reusable components
            from existing code using
            classes and class libraries (p
            191-190)

                                                                                                                         4
            Test classes and libraries in
             isolation (p 202)


Week 16    GridWorld case study [C7]
            Chapter 1 (Part 1) of the
             GridWorld case study


 Unit 8    Inheritance and                     UEmployee (p 236)         Text pages 211-246      C3 – The course
(weeks     Polymorphism [C3] [C4] [C5]         Vehicle (p 236)            (Chapter 9)             teaches students to
17. 18)    [C6]                                                                                    design and
                                               Account (p 236)           TRM Chapter 9
            Read and understand class                                                             implement
                                                                           Lesson 1                computer-based
             specifications and                Simple applications to
                                                reinforce concepts        TRM Chapter 9           solutions to
             relationships among the                                                               problems in a variety
                                                (Reviews p 214-225)        Lesson 2
             classes (is-a relationship) (p                                                        of application areas.
             211)                              SalesCenter Case          TRM Ch09 Lesson 1
                                                Study (p 225-232)          Worksheet 1 dynamic
            Understand and implement a
                                                                           binding
             given class hierarchy (p 211-     Modify existing
                                                                                                   C4 – The course
             214)                               SalesCenter code (p                                teaches students to
            Extend a given class using         232)                                               use and implement
                                                                                                   commonly used
             inheritance (p 212-214)           Critical Thinking 1-7                              algorithms and data
            Extend existing code using         (p 235)                                            structures.
             inheritance (p 212-214)           Test 8
            Interface declarations (p 223)
            The Comparable interface (p                                                           C5 – The course
             223-224)                                                                              teaches students to
                                                                                                   develop and select
                                                                                                   appropriate
                                                                                                   algorithms and data
  Unit 9   Arrays [C3] [C4] [C5] [C6]          Mastermind (p 267)        Text pages 237-272      structures to solve
 (weeks     One-dimensional arrays (p         SortedArray                (Chapter 10)            problems.
 19, 20,     237-238)                           (introduce Selection      TRM Chapter 10
   21)                                          sort) (p 269)              Lesson 1
            Traversing an array (p 238,
             251)                              Inventory (p 272)         TRM Chapter 10
                                                                           Lesson 2                C6 – The course
            Iteration (p 239, 251)            Simple applications to                             teaches students to
            Array element insertions and       reinforce concepts        TRM Ch10 Lesson 1       code fluently in an
             deletions (p 238, 265, 250-        (Reviews p 239-253)        Worksheet 1 hard-       object-oriented
                                                                           coded data              paradigm using the
             251)                              LocalBank Case Study                               programming
            Sequential search (p 244)          (p 254-263)               TRM Ch10 Lesson 1       language Java. The
                                                                           Worksheet 2 array       course teaches
            Introduction to algorithm         Modify existing                                    students to use
                                                LocalBank code (p          insertions and
             analysis (p 244)                                                                      standard Java library
                                                263)                       deletions               classes from the AP
            The ArrayList class (p 250-                                                           Java subset
                                               Critical Thinking 1-14    TRM Ch10 Lesson 2
             251)                                                                                  delineated in
                                                (p 265)                    Worksheet 2 ArrayList   Appendixes A and B
            The Integer class (p 251-253)                                 exercise
                                               Test 9                                             of the AP Computer
            The Double class (p 251-253)                                                          Science Course
                                                                                                   Description.

Week 22    GridWorld case study [C7]
            Chapter 2 (Part 2) of the
             GridWorld case study




                                                                                                                         5
Unit 10   Recursion and Advanced              Knapsack (p 362)          Text pages 337-364
(weeks    Algorithms [C3] [C4] [C5] [C6]      Simple applications to     (Chapter 13)
23, 24,    Selection sort (p 337)             reinforce concepts        TRM Chapter 13
  25)                                          (Reviews p 341-356)        Lesson 1
           The Comparable interface (p
            339)                              Critical Thinking 1-8     TRM Chapter 13
           Insertion sort (p 341)             (p 359-360)                Lesson 2
           Mergesort (p 345)                 Test 10                   TRM Ch13 Flash
                                                                          Movie Files sorting
           Recursion (p 343-344)
                                                                          and searching
           Binary search (p 349)                                         animations
           Informal comparisons of
            running times (p 356-357)
           Exact calculation of statement
            execution counts (p 356-357)


Unit 11   GridWorld case study [C7]                                                               C7 – The course
(weeks     Chapters 3 and 4 (Parts 3 and                                                         teaches students to
26, 27,                                                                                           read and understand
            4) of the GridWorld case study                                                        a large program
  28)                                                                                             consisting of several
                                                                                                  classes and
Weeks     Exam preparation                    Sample multiple-                                   interacting objects,
29, 30                                         choice questions and                               and enables
                                               free-response                                      students to read and
                                                                                                  understand the
                                               questions                                          current AP Computer
                                                                                                  Science Case Study
                                                                                                  posted on AP
Unit 12   Files and Exception                 WordCount (p 331)         Text pages 309-336      Central.
(weeks    Handling                            MadLib (p 332)             (Chapter 12)
31, 32)    Files (p 309)                                                Text Chapter 13
                                              HTMLViewer (p 333)
           Handling exceptions with try-                                 exercises (p 361-364)
                                              WordGuess (p 334)
            catch-finally (p 310)                                        TRM Chapter 12
                                              MySavings (p 334)
           File streams (p 311-316)                                      Lesson 1
                                              Life (p 335)
           Processing numeric data (p                                   TRM Chapter 12
                                              Simple applications to     Lesson 2
            314)
                                               reinforce concepts
           Object serialization (p 317-       (Reviews p 310-320)
            318)
                                              LocalBank2 Case
                                               Study (p 321-327)
                                              Modify existing
                                               LocalBanks2 code (p
                                               328)
                                              Critical Thinking 1-12
                                               (p 330)
                                              Test 12




                                                                                                                       6
 Unit 13       GUIs and Event-Driven             PhotoAlbum (p 307)        Text pages 273-308
 (weeks        Programming                       Clacker (p 307)            (Chapter 11)
 33, 34)        Graphical user interfaces (p                               TRM Chapter 11
                                                 LifeGUI (p 307)
                 273)                                                        Lesson 1
                                                 Simple applications to
                The Swing Package (p 273)        reinforce concepts        TRM Chapter 11
                Event-driven applications (p     (Reviews p 276-292)        Lesson 2
                 273-277)                        BreakAPlate Case          TRM Ch11 Dialog
                GUI layout and controls (p       Study (p 296-301)          Boxes PDF
                 279-292)                        Modify existing           TRM Ch11 Lesson 2
                Nested classes (p 293)           BreakAPlate code (p        Worksheet 1
                                                  301)                       additional GUI
                                                                             components
                                                 Critical Thinking 1-20
                                                  (p 305-306)               TRM Ch11 Lesson 2
                                                                             Worksheet 2
                                                 Test 13
                                                                             additional listeners


 Unit 14       Data Structures                   ParenChecker (p 379)      Text pages 365-380
 (week          Stacks (p 365)                  Stats (p 380)              (Chapter 14)
  35)                                                                       TRM Chapter 14
                Queues (p 369)                  DoublyLinkedList (p
                                                  380)                       Lesson 1
                Linked lists (p 373)
                                                 Simple applications to    TRM Chapter 14
                                                  reinforce concepts         Lesson 1
                                                  (Reviews p 368-376)       TRM Ch14 Lesson 2
                                                 Critical Thinking 1-8      Worksheet 1
                                                  (p 378)                    additional exercise
                                                 Test 14


Unit 14A       Applets and Web                   copyright (p 57)          Text pages 35-58
(week 35       Programming                       technology_report (p       (Chapter 2)
alternative)    World Wide Web terminology       57)                       TRM Chapter 2
                 (p 35)                          Simple applications to     Lesson 1
                Impact of programming on         reinforce concepts        TRM Chapter 2
                 the WWW community (p 35-         (Reviews p 38-51)          Lesson 2
                 36)                             Critical Thinking 1-10
                HTML (p 36-37, 45-48)            (p 55)
                JavaScript (38-41)              Test 14
                Java applets (p 41-42)
                HTML style sheets (p 49-50)


Week 36        Final Exam




                                                                                                    7
              APCS A Topic Outline Correlation                                                         [c2]


I. Object-Oriented Program Design

A. Program design

1. Read and understand a problem description, purpose, and         Unit 3 (p 90-93), Case Studies in Units 4 through 14
goals.

2. Apply data abstraction and encapsulation.                       Unit 7 (p 179-182)
3. Read and understand class specifications and relationships      Unit 7 (p 187), Unit 8 (p 211)
among the classes (“is-a”, “has-a” relationships).


4. Understand and implement a given class hierarchy.               Unit 8 (p 211-214)


5. Identify reusable components from existing code using classes   Unit 2 (p 59-60), Unit 3 (p 80-81), Unit 7 (p 191-
and class libraries.                                               192)

B. Class design

1. Design and implement a class.                                   Unit 7 (p 180-182)
3. Choose appropriate data representation and algorithms.          Unit 7 (p 179-185)


4. Apply functional decomposition.                                 Unit 7 (p 180)
5. Extend a given class using inheritance.                         Unit 7 (p 186-187), Unit 8 (p 212-214)


II. Program Implementation

A. Implementation techniques

1. Methodology
    a. Object-oriented development                                 Unit 2 (p 59), Unit 7 (p 191-192)
    b. Top-down development                                        Unit 6 (p 157)
    c. Encapsulation and information hiding                        Unit 2 (p 59), Unit 7 (p 182)
    d. Procedural abstraction                                      Unit 6 (p 157)
B. Programming constructs
1. Primitive types vs. objects                                     Unit 3 (p 79-80)




                                                                                                                          8
2. Declaration
    a. Constant declarations                            Unit 3 (p 87)
    b. Variable declarations                            Unit 3 (p 77-80)
    c. Class declarations                               Unit 7 (p 180)
    d. Interface declarations                           Unit 8 (p 223)
    e. Method declarations                              Unit 6 (p 159-160)
    f. Parameter declarations                           Unit 6 (p 160-161)
3. Console Output (System.out.print/println)            Unit 2 (p 63)
4. Control
    a. Methods                                          Unit 6 (p 157-160)
    b. Sequential                                       Unit 2 (p 61)
    c. Conditional                                      Unit 4 (p 105-108)
    d. Iteration                                        Unit 5 (p 131, 135), Unit 9 (p 239, 251)
    e. Recursion                                        Unit 10 (p 343-344)
C. Java library classes
                   java.lang.Math                       Unit 4 (p 109-111,113)
                   java.lang.String                     Unit 5 (p 138-141)
                   java.lang.Integer                    Unit 9 (p 251-253)
                   java.lang.Double                     Unit 9 (p 251-253)
                   java.lang.Comparable (interface)     Unit 8 (p 223-224), Unit 10 (p 339)
                   java.lang.Object                     Unit 7 (p 185-186)
                   java.util.ArrayList                  Unit 9 (p 250-251)


III. Program Analysis

A. Testing
1. Test classes and libraries in isolation.             Unit 7 (p 202)
2. Identify boundary cases and                          Unit 6 (p 168)
generate appropriate test data.
3. Perform integration testing.                         Unit 6 (p 170-171)
B. Debugging
1. Categorize errors: compile-time, run-time, logic.    Unit 3 (p 88-89)
2. Identify and correct errors.                         Unit 3 (p 88-89), Unit 5 (p 132)
3. Employ techniques such as using a debugger, adding   Unit 5 (p 136-137)
extra output statements, or hand-tracing code.




                                                                                                   9
C. Understand and modify existing code                    Unit 4 (p 118), Unit 5 through 14
D. Extend existing code using inheritance                 Unit 8 (p 212-214)
E. Understand error handling
1. Understand runtime exceptions                          Unit 3 (p 89)
F. Reason about programs
1. Pre- and post-conditions                               Unit 6 (p 164-165)
2. Assertions                                             Unit 6 (p 164-165), Unit 6 Lesson 2 (TRM)
G. Analysis of algorithms
1. Informal comparisons of running times                  Unit 9 (p 244), Unit 10 (p 356-357)
2. Exact calculation of statement execution counts        Unit 10 (p 356-157)

H. Numerical representations and limits

1. Representations of numbers in different bases          Unit 1 (p 9-10), Unit 2 Major Project, Unit 6
                                                          Lesson 2 Worksheet 1 (TRM)

2. Limitations of finite representations (e.g., integer   Unit 1 (p 10-11)
bounds, imprecision of floating-point representations,
and round-off error)


IV. Standard Data Structures

A. Simple data types (int, boolean, double)               Unit 3 (p 77-79)

B. Classes                                                Unit 3 (p 80), Unit 7 (p 179-185)
C. One-dimensional arrays                                 Unit 9 (p 237-238)

V. Standard Algorithms

A. Operations on A-level data
structures previously listed
1. Traversals                                             Unit 9 (p 238, 251)
2. Insertions                                             Unit 9 (p 238, 265, 250-251), Unit 9 Lesson
                                                          1 Worksheet 1 (TRM)
3. Deletions                                              Unit 9 (p 238, 265, 250-251), Unit 9 Lesson
                                                          1 Worksheet 1 (TRM)
B. Searching
1. Sequential                                             Unit 9 (p 244)
2. Binary                                                 Unit 5 Major Project, Unit 10 (p 349)




                                                                                                          10
C. Sorting
1. Selection                                Unit 10 (p 337)
2. Insertion                                Unit 10 (p 341)
3. Mergesort                                Unit 10 (p 345)


VI. Computing in Context

A. Major hardware components

1. Primary and secondary memory             Unit 1 (p 2)
2. Processors                               Unit 1 (p 2)
3. Peripherals                              Unit 1 (p 1)
B. System software
1. Language translators/compilers           Unit 1 (p 5-6)
2. Virtual machines                         Unit 2 (p 62)
3. Operating systems                        Unit 1 (p 2-4)
C. Types of systems
1. Single-user systems                      Unit 1 (p 1)
2. Networks                                 Unit 1 (6-9)
D. Responsible use of computer systems
1. System reliability                       Unit 1 (p 22)
2. Privacy                                  Unit 1 (p 18-20)
3. Legal issues and intellectual property   Unit 1 (p 21)
4. Social and ethical ramifications of      Unit 1 (p 22)
computer use




                                                               11

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:18
posted:6/23/2011
language:English
pages:11