CS112: OOP and Web Project Foundations

MiraCosta CS112 outline: available lessons, supporting AP practice, authoring gaps, and Web project extensions for each college topic.

Source ownership follows CS112, CS113, CSA1, CSA2, then DS2. Week assignments remain in the shared CSA course plan. Articulation metadata identifies a curriculum connection, not earned credit or demonstrated mastery.

CS112 Instruction / Examples

This report follows MiraCosta's CS112 outline, not the AP question order. AP FRQs are supporting practice within the relevant college topic; their titles retain the practice category and original exam identity. A lesson may support more than one topic without becoming an additional assignment.

Teaching stage: FRQs are taught in CSA2 and beyond. Their placement under a CS112 topic records articulation alignment, not CSA1 instruction or a change to the shared course schedule.

Early Web foundations: POJO, JPA, and APIs are introduced in CSA1 week 4, building on students' prior Python Web and API work in APCSP. These familiar project patterns provide an entry point into Java; later CSA2 and DS2 lessons deepen the related CS112 concepts.

Weeks and supplemental status come from the current lesson metadata. Drafts are authoring work, not live assignments. Coverage notes describe available material, not earned credit or demonstrated mastery.

Mapped Java Reference lessons supplement this outline. Their original ownership and week assignments are unchanged; inclusion here does not add an assignment or claim articulation credit.

I. Object-oriented programming (OOP): design and analysis

A. Encapsulation, inheritance, and polymorphism

Available material: Class-writing FRQs support constructors, encapsulation, and methods. Interface, inheritance, and Collectable examples extend this into polymorphic design.

Strengthening / gap: Strengthen the connection between isolated class exercises and a tested, multi-class Web feature.

PBL observation or extension: Observe a Spring entity and controller, then extend the model without exposing internal state.

B. Abstract classes and generics or parameterized types

Available material: The abstract Fibonacci and Collectable lessons demonstrate abstract parents, interfaces, and typed collections.

Strengthening / gap: Add a focused student-authored generic class exercise; using ArrayList<T> alone does not demonstrate designing a parameterized type.

PBL observation or extension: Extend a shared Collectable abstraction and explain the type contract used by its collection.

II. Software engineering design: techniques and strategies

A. Memory management and garbage collection

Available material: Stack and heap memory, reference types, and object-copying notes provide the foundation.

Strengthening / gap: Finish the copying/memory draft with reachability, garbage collection, and object-lifetime checks.

PBL observation or extension: Trace references held by a controller or collection and explain when an object becomes eligible for garbage collection.

B. Visibility, scope, binding, and lifetime

Available material: Java Scope and Access explicitly covers visibility, shadowing, private fields, and accessors. Reference passing, class variables, POJOs, and class-writing practice support local-versus-instance state.

Strengthening / gap: Extend the existing scope instruction with dynamic method binding and object-lifetime comparisons.

PBL observation or extension: Compare request-local variables with entity fields and inspect an overridden method's runtime behavior.

III. Advanced language elements

A. Copy constructors

Available material: Reference and memory lessons are prerequisites; a dedicated object-copying skeleton exists.

Strengthening / gap: The copy-constructor lesson is unfinished. Require shallow/deep-copy tests rather than treating reference assignment as copying.

PBL observation or extension: Create an independent snapshot of project data and verify that editing the original does not change the snapshot.

B. Advanced input/output techniques - 1. Text and binary files

Available material: Java Using Text Files covers File/Scanner reading, token versus line input, resource closure, and empty-file handling. JPA adds persistence context but is not a substitute for file I/O.

Strengthening / gap: Extend the text-reading foundation with text writing, binary import/export, and round-trip tests.

PBL observation or extension: Add an export/import layer to a project collection and compare text and binary representations.

B. Advanced input/output techniques - 2. Random access files

Available material: The reliable-file-persistence draft includes fixed-size records and RandomAccessFile offsets.

Strengthening / gap: No completed dedicated random-access file lesson is available in this collection.

PBL observation or extension: Update one fixed-size record by its offset without reading or rewriting every record.

C. Recursive methods

Available material: Java Recursion explicitly covers base cases, progress, call-stack tracing, and recursive methods. Recursive Searching and Sorting extends this to arrays, ArrayLists, and binary search; Fibonacci adds an algorithm-comparison context.

Strengthening / gap: Apply the existing recursion checks to a student project and compare recursive and iterative costs; ordinary method-writing FRQs are prerequisites, not recursion evidence.

PBL observation or extension: Compare recursive and iterative implementations, then explain the call-stack cost.

D. Fault-tolerance through exception and error handling

Available material: Java text-file instruction introduces file-opening errors and resource handling. Backend and file-persistence materials provide contexts for invalid input, failures, and recovery.

Strengthening / gap: Finish a dedicated exercise that tests failure paths, useful error reporting, and safe resource handling.

PBL observation or extension: Send invalid input or a malformed import to a project feature and verify the reported error and unchanged valid data.

IV. Advanced data structures

A. ArrayLists, vectors, linked lists, and iterators

Available material: Collection/list lessons and array-processing FRQs provide traversal, modification, and iteration practice. The 2D example is supporting array practice, not a separate CS112 outline section.

Strengthening / gap: Finish the from-scratch LinkedList layers and explicitly compare Vector with ArrayList. Library usage is not a custom implementation.

PBL observation or extension: Build a small review queue using student-authored nodes, insertion, and traversal, with empty and singleton tests.

B. Data structure assessment and appropriate selection

Available material: Collection introductions, summaries, Comparable, and queue references support choosing structures for project needs.

Strengthening / gap: Require students to justify their selection using actual operations and test data. Deeper sort analysis belongs to the CS113 extension.

PBL observation or extension: Compare a list and a map for a project's lookup needs, then justify the chosen structure.

V. Graphics

A. Graphical user interface (GUI) design

Available material: Fullstack design, frontend UI, Thymeleaf, and concrete viewer/game examples support browser-based GUI design.

Strengthening / gap: Strengthen accessibility, validation, and user-flow evaluation in student project evidence.

PBL observation or extension: Evaluate a form or table with a user, then improve its feedback and keyboard interaction.

B. Java applets or Web

Available material: Use the Web pathway: Spring-backed pages, frontend/backend integration, JQuery, and generated CRUD tables. Applets are not the teaching target.

Strengthening / gap: Require an end-to-end feature with a clear API contract and demonstrated success and error states.

PBL observation or extension: Connect a browser interaction to a Spring endpoint and persist or retrieve project data.

Lab Outline

Individual and group hands-on projects

Available material: Projects support, complement, and extend lecture material and theory. Existing feature documentation provides examples to observe and extend, not proof that students have implemented the underlying CS112 concepts.

Strengthening / gap: Collect individual competence evidence alongside group project work, followed by summative evaluation and reflection.

PBL observation or extension: Choose a feature, identify its CS112 concepts, implement an extension, demonstrate it, and reflect on test evidence.