[{"run_id":"20260906T231458-5fdd2fff","semester":"1272","observed_at":"2026-09-06 23:14:58.172943+00:00","record_version_id":"b26f0644f0d5fe1a0cf70536ca67a1c184a5b971fb7f8a304eb1e8e4a0e5b2d5","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"20260907T155543-ce3781c4","semester":"1272","observed_at":"2026-09-07 15:55:43.033547+00:00","record_version_id":"b26f0644f0d5fe1a0cf70536ca67a1c184a5b971fb7f8a304eb1e8e4a0e5b2d5","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-03b0bbb9723907cf3d1b41cf0bb34837dc398e42","semester":"1262","observed_at":"2025-04-16 05:20:33.104844+00:00","record_version_id":"dc1e07194c998ad513c84b636c84cd18c819f9b1f8b6f63fccf7ea6134fb664d","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-0837245627eb714ae6bb0375f7abe8f41042011f","semester":"1262","observed_at":"2025-04-16 05:20:33.104844+00:00","record_version_id":"dc1e07194c998ad513c84b636c84cd18c819f9b1f8b6f63fccf7ea6134fb664d","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-08c92e359bbbc110b0778b7e0b15d6f40000e6b1","semester":"1262","observed_at":"2025-08-21 07:05:14.730696+00:00","record_version_id":"b0621f9bb900ce23320ec710aa4356b51449591368dd0c75774b4e31434384f6","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-0944d76440dc778fbb89626058c10451009ce9c6","semester":"1262","observed_at":"2025-05-21 03:36:18.194118+00:00","record_version_id":"df2443fe36f859684f7aef9fa18cc572df74c887dad07c12ffed81e41ef1ccc9","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-0a7f4bce29c816ef4d3d71b4eb8a2a3e15e33cc1","semester":"1262","observed_at":"2025-06-18 20:04:02.695444+00:00","record_version_id":"8f266cf8d56b998fbd0bbfd515669d034f1389e8fe7cffe67e6641fe785d294f","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-0ab917f827a7de22ebdc1087114d377a31c4687b","semester":"1262","observed_at":"2025-05-22 02:11:02.531191+00:00","record_version_id":"9924fd5404520593a817eb48b59c507b5f376261a14474bfb586bef25828aaaf","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-0c40ecab4b6db9333d1f18aef816e3ee659e300c","semester":"1262","observed_at":"2025-05-25 18:02:34.797617+00:00","record_version_id":"d7b8074c793fa3f762f37aab6c40c807cd2c2a19005042fa172cd03b9dbed3d1","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-0cb4d29a588ec7f11c7e00b7cf5dc3a0d23d0349","semester":"1266","observed_at":"2026-01-22 01:00:26.555427+00:00","record_version_id":"91b730bc3ca2e1938461e03d044ef7fc603d18eb1794ce1aba9e25a1f5fb0a3f","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-11c30ec39e91498cbfcf3a923c53a4b03e387280","semester":"1262","observed_at":"2025-07-20 04:58:26.847117+00:00","record_version_id":"7e9cfe57ab5d7313177796be2ee0bb06e6a308080d626f1312e3cbc2b5ca69b4","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-13cd500edf2587e9a3428f326253738fbea965ea","semester":"1264","observed_at":"2025-12-14 04:50:04.653658+00:00","record_version_id":"e40d3100b6d44ac3066f69246bc06379b157e86e8a41bc295728fda98cdbb3e9","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-1da08b2de39f05e6bc877c189fc2fd6eeda563f5","semester":"1262","observed_at":"2025-07-01 00:03:56.707251+00:00","record_version_id":"ab29875e5e67ecd4dd7b5cc768efba9d082d4257f4c5db1aab5fc9b15da8f1e7","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-2031af47efe133b0e7877f433286ff07385afc41","semester":"1262","observed_at":"2025-07-02 20:16:45.749584+00:00","record_version_id":"a7a25834f5bc4b5a4bda7381f5a4ad94f874581d79dfb32b53b69855250fd0eb","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-238eba6f32fbc30407f616dd0628ff02a2a824dd","semester":"1262","observed_at":"2025-08-17 05:15:07.788352+00:00","record_version_id":"e3702d0b641de33faf62bfb0f5a85e73dc631e47278e59a136d7385134571984","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-25f0ff56bc4d80f8a8afa1a0bcce8dae6fddb5e5","semester":"1262","observed_at":"2025-05-25 17:20:25.942090+00:00","record_version_id":"9622647e1904958bcf1d71f2ee4e6cc61f0ab793bc192fd672916350f64612e5","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-2923f91826ce253b7aeefa9f75b4a39fe4c80ff0","semester":"1262","observed_at":"2025-08-10 05:10:25.938416+00:00","record_version_id":"a316091a9d05d69b419b906a4697eb496b098c2069b8753f1b9ba74b8aa1cfb0","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-2a05214a4023e0157fa6f7d188c85308f714176c","semester":"1262","observed_at":"2025-09-07 04:56:38.255315+00:00","record_version_id":"ba7f781c2a74fb3d5aa344c1d549c90b974539fe3839be570d46307a5e707209","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-2b1b8e39131de92b94620b25c5bbb25690efed4c","semester":"1262","observed_at":"2025-06-01 07:54:53.913454+00:00","record_version_id":"b3f2a114d92e353ee25698e572257de45d85eaf302ab53b1efb6d3850db35600","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-33a1225644e5a5855d60f66e65413946e72fedf4","semester":"1262","observed_at":"2025-06-22 01:52:05.152650+00:00","record_version_id":"066b6a4ae7b52de15649d64fec3992923831033807bb20b689c72e2fdd919f7d","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-3b89c83dbf5208e13756184de1f2b2d0c09af35f","semester":"1262","observed_at":"2025-06-30 06:40:10.235522+00:00","record_version_id":"a1428cc21a6127c14e45b5616c0765f724c6c9e99bfc17ed73d1bce49716a143","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-3c3eebf7f35c39364b445a2fa5a112ce28dbb4a1","semester":"1262","observed_at":"2025-06-01 17:03:59.062985+00:00","record_version_id":"e0f4c8696efce70858d82e2eb0f249cdd17b2af730fb6e41372d58c14815ed04","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-3fa4dd71391f1c9cf4ab2216680bbc428689f92d","semester":"1262","observed_at":"2025-05-25 01:15:58.180530+00:00","record_version_id":"a2a8074c006ca7bfc267dfa709ba8f86670a70cf94aa2088891baa4deb698126","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-4040aa216da722a34483f68fc1e129ea571ae08d","semester":"1262","observed_at":"2025-06-01 07:27:39.695506+00:00","record_version_id":"e8c8fb3219c63e001b0aea2b7007fb12e662037f01e463ad614e025f7cea9d53","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-454d53cd690294459f8ad0793cc3ed562060e56c","semester":"1262","observed_at":"2025-05-25 01:34:00.536004+00:00","record_version_id":"b5d1bd08475e2e212bcd2ddded5f69728681acc7324490df1624bf2400a86bb8","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-486f091e051fdb4ccdb80ee7b4fb0a5814510324","semester":"1264","observed_at":"2025-11-16 05:32:31.273726+00:00","record_version_id":"e7e6ee81070aec7d0fe65b7f598eee75c1494f7fd7619a88ff5342c81c942cad","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-50393cfc5fd5598d4f4731ef1919f2ff53af07d9","semester":"1262","observed_at":"2025-06-30 06:05:57.438846+00:00","record_version_id":"3918c570e3bc17e018658579e5c68f051517beee2a31370976f0ee7431abb999","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-50f6947786b208c800db8bbd0cec84a8f0f187d2","semester":"1262","observed_at":"2025-06-02 03:49:42.915428+00:00","record_version_id":"68205cc835ead67fda9caee748d4d3edb12d1089456d77c9376ffdb29654b500","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-51d86ed4082dced3803c295419b0ec8440942016","semester":"1264","observed_at":"2025-11-12 04:50:41.141307+00:00","record_version_id":"94d329a0ed1616b2faa423e21abaf994afc13bf67e1ec6811d5914c8cf3dcd21","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-53101bd1c10db0d00d094e4c9154d4c244ff23d9","semester":"1262","observed_at":"2025-10-05 04:58:05.366968+00:00","record_version_id":"3dccf87bb963b46c2f417dfec5ea76d33097f8816436df5147d07234bb02c485","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-58751151c564e11c5cb8aedd3a2d3527c22f73eb","semester":"1262","observed_at":"2025-06-01 06:59:01.536576+00:00","record_version_id":"380706e0994778bbdce9c1115233530676c4c8494894c225184146962a8c7e80","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-5c4c8d3701a333ba4ddadef7d0b5dde8440fcdf0","semester":"1262","observed_at":"2025-06-01 01:57:51.256704+00:00","record_version_id":"e4a5ce687c70e759b0dd910d75cb2f35d324b6a5fe8826edd5c9631007a07359","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-5d20d9f81651d3c83fcaa2fd10870ce6e5d5a685","semester":"1262","observed_at":"2025-05-21 16:48:48.484741+00:00","record_version_id":"24e999856a8970d9aff37ca4249abd4f2be002ad4ee20fc5144d7f66542f265e","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-5feaebf2ab37051c86ad360cc0fa0d7e0e2ea295","semester":"1262","observed_at":"2025-05-24 15:58:23.378859+00:00","record_version_id":"1687558b075c5901082a092ceb1e7ea46f079b075529e133c1afa07c3dc4086f","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-60949965544fce098cc006354e201149005fb77b","semester":"1264","observed_at":"2025-10-26 05:07:14.077864+00:00","record_version_id":"62f211076cff95273bb84e7558a1d3877ff6f98258c52ede984ca195c221c55f","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-639225ac3addf8522f1d30cb4fe26054ea7f8c49","semester":"1262","observed_at":"2025-06-01 08:14:42.497608+00:00","record_version_id":"9799736e64ba08e3d2188dc74e4f694c539c908aa54cb78285cfdafdc15e8178","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-64093b17b3a9c67a41aa33eb37adb53ec38df714","semester":"1262","observed_at":"2025-05-22 02:11:02.531191+00:00","record_version_id":"b3d943bcc8b7facc727b4eb31cd43cb9c6ebacd59d76f5cec279960be60f7991","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-6885b56099f55e08aa0205546369fb0381d50e13","semester":"1262","observed_at":"2025-07-13 04:59:22.367394+00:00","record_version_id":"e961c393f7f843f3ed42eba1f04569a4bd6a357796bd741b94c59a54af1b4dc5","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-69d4b2b16e8268f75b6390b3a0e2ce8bf73999da","semester":"1262","observed_at":"2025-06-30 03:21:29.925498+00:00","record_version_id":"8f57560a72e06c1ffa043a88292b10e360bf8a76b4c64cacc93b041871b224bb","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-6b29c3e0673b2f9a736d2363db5409e03d5b3ed4","semester":"1264","observed_at":"2025-12-03 12:33:41.418072+00:00","record_version_id":"5b3fc608f5abc58a8c21834abd6c8b322920b6f317cd576929334accc531e558","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-73259984748de484976ef2ad56ad7ab3d4cb4518","semester":"1262","observed_at":"2025-06-26 08:27:56.461216+00:00","record_version_id":"892b8f6a6fd559bc4260b39829dc76fb455b06d6fdf3c0232d24add02873cf91","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-741602fbc6252c232a0b9e6bc1a9ae3101625f5a","semester":"1262","observed_at":"2025-06-30 22:49:32.522034+00:00","record_version_id":"2df2e47d2bf976eeaf549f591e058e1b2c19b50467782d2115812fee4523b132","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-7774f45558276ec29bf626e58fffb4a27bdbb2a9","semester":"1264","observed_at":"2025-11-01 11:49:36.359151+00:00","record_version_id":"b02c788173960879516e0eb9b09819c1b06044dc628b2511cb49eb4c7ed0324e","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-7ab7c5e783fc8ebef8b8ee8cea019ee37a72ce74","semester":"1262","observed_at":"2025-09-28 04:58:07.340658+00:00","record_version_id":"b667989a9bf8a02654b5ee4e408839444420709a4141219bfa3448ca580b9163","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-7b2f22d83ea05055ab90dcb77dc802382cccc6f7","semester":"1262","observed_at":"2025-05-21 17:56:46.096741+00:00","record_version_id":"d1d60c1651e9e78aa2682c925b70073f08da0403ce290a0abe176ec9b2a3f86b","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-7ca1175502be18eb51f7b016818a884a43fd4ebb","semester":"1262","observed_at":"2025-07-29 06:28:23.644795+00:00","record_version_id":"56edf66e5cc8b75505c14a129890a46e64ced02e719687e6128aedb9131d79b6","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-7d8cee5e42602ad9ba5dc0322085af2fa0dffaac","semester":"1262","observed_at":"2025-05-22 01:15:19.291664+00:00","record_version_id":"dc2a38b86d6593158aa6422521f0151557e5d875ebe6ebcf0aeebc657d3e4b83","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-81a0d6a7f668c98c59bd05fa988aa079c5ad1f68","semester":"1262","observed_at":"2025-05-31 07:49:50.419452+00:00","record_version_id":"b004e4b42dfb153b13280014918efe2819e24912a47df7a56490217ae8ba5158","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-82f31c08c746a214872494cde6ecaeb9330441b4","semester":"1262","observed_at":"2025-06-17 21:26:08.547156+00:00","record_version_id":"93c68576a95ef2d59c4f675484968e194b61986c0c0c91c8560d8c46025f5804","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-84c248343c5a99ab42c5616c594812a5e3e31cbb","semester":"1262","observed_at":"2025-07-04 06:00:07.487827+00:00","record_version_id":"f7f725004aa1d2039aa760b1cb4f857f414422bd35b8f31ea98f6f9a0f80ef0c","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-86334e7275e315853287e8580c35456c68df800b","semester":"1262","observed_at":"2025-05-22 06:53:03.336354+00:00","record_version_id":"c51ea6dee43f3f34a6ed53c8e9eae34ce66b3c132555d16c09d3281e29a28cf2","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-8686dc1664f93a6c05f50321410961b39b12f91b","semester":"1262","observed_at":"2025-05-28 10:17:41.595894+00:00","record_version_id":"17d34dc360e2a044fd7fc9dbe0fcb179d9c69d36041e7935aeda1078f6b5d27c","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-86d941366886c9a14a2581c04e20d0bdd25e1b02","semester":"1262","observed_at":"2025-08-31 04:54:14.656039+00:00","record_version_id":"0a51c729d25a4a1237893c1842cdac387cf95963003b29faf04b0466866a01ae","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-8ba1d2e6cfbb1525b4f9f769ec164fb6ad0f237a","semester":"1262","observed_at":"2025-06-02 05:22:45.010398+00:00","record_version_id":"b3cdbb396f9c1f0d11e3053ae6ef89cbf9df0c71d07974130f3d6f8f14ae6772","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-90e5aa456689a3b222016c05c319bbcd0bddd453","semester":"1262","observed_at":"2025-05-25 02:00:10.037905+00:00","record_version_id":"13e51bb6865073f1087de208997efbf48706423b486629bd5f520628435c8bdd","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-92d960aa7e4cd6e4c9ac8b2e232092904038e9e4","semester":"1262","observed_at":"2025-06-08 01:50:46.451351+00:00","record_version_id":"b8a654535d2ce365cdd929b00f1d18c8d876ab4784cbae4b94c937fdeb7021aa","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-94002ae588a8f71eca6d64105f2e603e8587293b","semester":"1262","observed_at":"2025-05-21 09:01:16.021508+00:00","record_version_id":"7878c94ccc2d69ec39af7ec2da7d8ccf9290a067a4d782300e7eacf9a72174a4","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-9dd575e013c5c6e000ab3ad2d1288cc1dd9c96dc","semester":"1264","observed_at":"2025-12-21 04:47:46.589081+00:00","record_version_id":"4356136950afe787de0cc736ee0ff61386de581621161d8776ef32c9500281f0","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-a1ea26ed78cbd6e94bc3221e50a6ed9b6bf43871","semester":"1262","observed_at":"2025-05-25 09:16:55.180581+00:00","record_version_id":"2d5bafc0700373fb9d47a511aba289d61f26216eb785e192c559fb7defa5e2ab","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-a76a3505853d5ea9c13bb98472b87361d469e2ee","semester":"1262","observed_at":"2025-05-28 18:03:41.793846+00:00","record_version_id":"47bc09f659b5a32e3d1dd86299768b5541c466ec06b01b97d754be77798d0852","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-b285d591f6acf3aa1910e02edc297664db86eb8c","semester":"1262","observed_at":"2025-06-10 22:48:22.460295+00:00","record_version_id":"6679aaebf3927da84ec04ad2de596ff3109ce4912c2836bbed21ecab21b5215e","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-b79af756e4f00ba98231feb859ed8e98239eb811","semester":"1262","observed_at":"2025-05-22 02:47:56.931581+00:00","record_version_id":"bd93123e5c9669b66440e691b5d0974d47f4f5b982ddfecbbc5dcddb4be33a33","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-b89e05b94730c6471439082d9279c0a834a4aeec","semester":"1262","observed_at":"2025-08-26 20:25:42.325239+00:00","record_version_id":"ba3da06abd9cba976fcb7c61edbec38faf1ec0cc28f7ccae8103f8eaacdff512","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-b9279a12d1f2688df9e556183c94d41a89e431dc","semester":"1262","observed_at":"2025-07-06 01:49:47.203835+00:00","record_version_id":"958e59812863887f73c3e0a0da99dd58385e8a38b8e8296e263f53310a1bcbde","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-bbdc905e96cc681a5e9a8b02c795b682206e36d1","semester":"1262","observed_at":"2025-06-25 08:02:45.445730+00:00","record_version_id":"e9137e20fe68652906a47733edd005a05adf663f0815ab72dc4fb512c1abb183","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-bde225b5243a13d81827aa173e39c78a652b54a0","semester":"1262","observed_at":"2025-05-23 07:22:33.219345+00:00","record_version_id":"2c6d4c94bdf9a360c602af0c491b819e6285c36eedbeead5aaec70f30cb8af04","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-c1fac4cbfde737f4f4ac02cdf15e6f5a9b5b676d","semester":"1262","observed_at":"2025-05-22 01:15:19.291664+00:00","record_version_id":"dc2a38b86d6593158aa6422521f0151557e5d875ebe6ebcf0aeebc657d3e4b83","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-c6b62be45f8a13cba109ef2a7741b9cd9a6b8272","semester":"1262","observed_at":"2025-08-24 08:48:09.035112+00:00","record_version_id":"d48e4920a97074a8f5c649b7f322ba9392f8a2595cd7df00871eb6f706fc6f25","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-cc83f62cb6db61f39320916d819ad48ce55cd96d","semester":"1262","observed_at":"2025-05-22 00:45:35.735230+00:00","record_version_id":"353ff5d372db434ba534bf37c544e13a618ee90acaf2d96588942b876b9c719a","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-d33818a01b6b4c5e2902e704da6e5b713742d4dc","semester":"1262","observed_at":"2025-10-13 10:46:24.251475+00:00","record_version_id":"e5d4ce7a9400334d11ca778e49f820f77e8e27c5bbcb94b456f7ac7629fc34c9","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-d3c17db9832d3064916046caf891dd23f10b1bb9","semester":"1262","observed_at":"2025-08-26 11:30:42.288639+00:00","record_version_id":"1ce5b4fe8a9af144ea5574428d886fe8f56f860568697e1f4ee4fbe8be828659","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-d4ee226dc44268e9b6767fb9f5f20343322f494b","semester":"1262","observed_at":"2025-06-15 01:52:23.911697+00:00","record_version_id":"610b6d95a64af1755c8165b90352d7707d5174bcd266b57db428a043af2698aa","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-d8f9fc7f136e2033556d9d65bbdbdf33425dbdc9","semester":"1262","observed_at":"2025-05-28 16:48:12.400438+00:00","record_version_id":"bad1cfa0e92d1f250c2e6070e1127804a14310be79ac315caa14c4956fb01812","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-dbbc9739c616c3846b2e796e00a36fa41225f7d8","semester":"1262","observed_at":"2025-06-01 17:47:19.325144+00:00","record_version_id":"7c9e559d0715207206019fc641d865df196d190c5132643c0e550f6b4972416d","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-dbe5f2d24b48c3177297a3d69c553cc9d1194bac","semester":"1262","observed_at":"2025-09-14 05:00:27.366070+00:00","record_version_id":"e2d59399e2b87a0a6f8b8b09b393502b516f2f99ef48279f68a3cb9e351aad21","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-dd357dc2758e9e282c30988a527ce37de92593b9","semester":"1264","observed_at":"2025-10-19 01:39:41.951404+00:00","record_version_id":"cd4cda055376a5e3d931ebfa04f0141c6c8e872327ee21c56c60f1bfa7d449c9","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-de74de559e409a3fe668685e28043b888d2e6841","semester":"1262","observed_at":"2025-06-27 07:38:50.882897+00:00","record_version_id":"d013fdb6d02ccfba6f6faab081b2f19e89f90313fb906555420e5f874d1f58c3","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-deca7188cf536ade3203cd88b52a45e92a059617","semester":"1262","observed_at":"2025-06-27 00:37:46.087071+00:00","record_version_id":"7c7883db74877ae59511c44c04baaa75887f4e75229a7eaa71360c38531b1243","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-df60fa9ac3931c5612b0fa641b7a6f5fbec86fab","semester":"1262","observed_at":"2025-05-24 06:36:37.554678+00:00","record_version_id":"37cc78b7909578a446c16718011f221a01aededa679379f9fe73431e27c3c6b4","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-e339da2d849aaf8bb4dceca07a84728af23cf755","semester":"1262","observed_at":"2025-07-23 08:49:22.748925+00:00","record_version_id":"d889ecb855196a4f4ac2b576db76455b8f3b4a9fead6d3b2044197cb83cb051e","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-e934b1784835f5d36ae9b7ef0992b11e72c39142","semester":"1262","observed_at":"2025-06-01 06:21:25.219533+00:00","record_version_id":"ac7bf9e2adcdfae1fe8e7a8122f4b296250c8a707e3592d879f4e68df6df7f60","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-ef471690c082448deebd2687eab84b0b78813c36","semester":"1262","observed_at":"2025-06-29 01:47:56.317645+00:00","record_version_id":"ef08837c2fb52e028221154e1607aa4d0e963d87528544a000b2a0b442f73a93","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-efc4e8e2cd7c3f68e059a308990c00c77c7611eb","semester":"1264","observed_at":"2025-10-16 05:48:13.935141+00:00","record_version_id":"b8e7e5c92b2af78284c1c5c584e18add864c9282215f11a8b1e722e2b4e0f1ed","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."},{"run_id":"legacy-f18b7749725097d41f69c60779ff38cf073b93b3","semester":"1262","observed_at":"2025-05-21 19:52:03.259353+00:00","record_version_id":"828595660f6b46480c197e3f543dc6732ab98ad74e8e7c407c470cb44ccf7192","course_id":"COMPSCI 300","course_uid":"course_28c3390ba944d49fd17f7c72","catalog_version_id":"7dfb1936f356107f17f132e2d94ef6da81470bae3e0f532ea9d7033a7b21f50d","course_number":300,"subjects":["COMPSCI"],"title":"PROGRAMMING II","description":"Introduction to Object-Oriented Programming using classes and objects to solve more complex problems. Introduces array-based and linked data structures: including lists, stacks, and queues. Programming assignments require writing and developing multi-class (file) programs using interfaces, generics, and exception handling to solve challenging real world problems. Topics reviewed include reading/writing data and objects from/to files and exception handling, and command line arguments. Topics introduced: object-oriented design; class vs. object; create and define interfaces and iterators; searching and sorting; abstract data types (List,Stack,Queue,PriorityQueue(Heap),Binary Search Tree); generic interfaces (parametric polymorphism); how to design and write test methods and classes; array based vs. linked node implementations; introduction to complexity analysis; recursion.","requirements_text":"Satisfied QR-A and (COMP SCI 200,220, 302,310, 301, or placement intoCOMP SCI 300) or (E C E/​COMP SCI  252andE C E 203); graduate/professional standing; declared in Capstone Certificate in COMP SCI. Not open to students with credit for COMP SCI 367."}]