12th Grade Computer Science

Students learn to mathematically evaluate the performance of code as input size grows, comparing linear, logarithmic, and quadratic growth patterns.

Students delve into the specifics of calculating time and space complexity for various operations, understanding the trade-offs involved.

Students master the concept of self-referential functions to solve problems, identifying base cases and recursive steps.

Students explore advanced recursive techniques like backtracking for combinatorial problems and memoization for optimizing recursive calls.

Students implement and compare linear and binary search algorithms, understanding their applicability based on data organization.

Students implement and analyze the performance of basic sorting algorithms, focusing on their step-by-step execution and efficiency.

Students implement sophisticated algorithms such as QuickSort and MergeSort, evaluating their stability and in-place sorting requirements.

Students learn about heap data structures and implement Heap Sort, understanding its application in priority queues.

Students explore Breadth-First Search (BFS) and Depth-First Search (DFS) algorithms for traversing graphs, understanding their applications.

Students explore pathfinding in grid-based environments, conceptually understanding how algorithms like A* find optimal paths by balancing cost and heuristic estimates.

Students explore the concept of connecting a set of points with the minimum total cost, understanding the real-world applications in network design and infrastructure.

Students learn how storing results of expensive function calls (memoization/caching) can significantly improve the performance of algorithms by avoiding redundant computations.

Students explore greedy algorithms, understanding when they provide optimal solutions and when they fall short.

Students explore the core OOP principles of encapsulation and abstraction, understanding how they promote modularity and data hiding.

Students design class hierarchies that promote code reuse and flexibility, implementing interfaces and abstract classes.

Students learn to write generic classes and methods that can operate on different data types, enhancing code reusability.

Students build and manipulate singly and doubly linked lists from scratch, understanding dynamic memory allocation.

Students implement stack data structures and explore their applications in function call management and expression evaluation.

Students implement queue data structures and understand their use in task scheduling and breadth-first traversals.

Students are introduced to binary trees and implement various traversal methods (in-order, pre-order, post-order).

Students implement Binary Search Trees, understanding how they enable rapid data retrieval and ordered storage.

Students conceptually explore self-balancing binary search trees like AVL and Red-Black trees, understanding their importance for performance.

Students are introduced to hash maps, exploring how these structures enable rapid data retrieval and various collision resolution strategies.

Students learn different ways to represent graphs (adjacency matrix, adjacency list) and understand basic graph properties.

Students learn to design software components with clear responsibilities and well-defined interfaces (APIs) to promote reusability and maintainability.

Students learn techniques for improving existing code's design without changing its external behavior, focusing on readability and maintainability.

Students learn the end-to-end process of data science, from data acquisition and cleaning to analysis and communication of results.

Students analyze massive datasets to find hidden trends, using statistical libraries to process and visualize complex information sets.

Students learn to create effective data visualizations to communicate insights and identify patterns in complex datasets.

Students are introduced to supervised learning, exploring concepts like regression and classification and how models learn from labeled data.

Students explore unsupervised learning techniques like clustering and dimensionality reduction to find hidden structures in unlabeled data.

Students conceptually explore how neural networks are structured, how they learn from experience, and the basics of deep learning.

Students learn various metrics and techniques for evaluating the performance and robustness of machine learning models.

Students examine the ethical implications of AI, focusing on algorithmic bias, fairness, and accountability in intelligent systems.

Students examine methods used to protect sensitive information in large databases, studying data anonymization techniques.

Students learn fundamental cybersecurity concepts, including confidentiality, integrity, and availability (CIA triad).

Students study encryption standards and hashing algorithms, understanding their role in data security and integrity.

Students explore common types of cyberattacks (e.g., phishing, malware, DDoS) and learn practical strategies for prevention and basic mitigation.

Students examine the ethical responsibilities and appropriate behavior for individuals in digital environments, including respecting privacy and intellectual property.

Students learn about the layered architecture of networks using the OSI and TCP/IP models, understanding how data flows.

Students study TCP/IP, DNS, and HTTP in detail, simulating how packets move across a distributed network.

Students explore how routers and switches direct network traffic, understanding concepts like IP addressing and subnetting.

Students investigate the principles of wireless communication, Wi-Fi security, and the challenges of mobile computing.

Students analyze common attack vectors like SQL injection, man-in-the-middle, and social engineering.

Students design defensive strategies for software applications and learn about security best practices for users and organizations.

Students understand the mathematics behind RSA and explore how asymmetric encryption allows for secure communication.

Students learn how digital signatures verify identity and integrity in a virtual space, and the role of digital certificates.

Students are introduced to the concepts of blockchain, understanding its underlying cryptographic principles and applications.

Students explore the security challenges and solutions associated with cloud computing environments.

Students learn about security features and vulnerabilities within operating systems, including user authentication and access control.

Students explore principles of secure software development, identifying and mitigating common coding vulnerabilities.

Students research and discuss emerging cybersecurity threats, such as quantum computing attacks and AI-powered malware.

Students investigate how unequal access to technology creates social and economic disparities globally.

Students evaluate software for universal design and accessibility standards, understanding the importance of inclusive technology.

Students analyze how robotics and AI are transforming the labor market, researching industries susceptible to automation.

Students explore the legal frameworks of software licensing, including copyright, patents, and trade secrets.

Students compare proprietary models with open-source movements and creative commons, understanding their impact on software development.

Students examine the balance between individual privacy, government surveillance, and corporate data collection in the digital age.

Students explore various ethical frameworks (e.g., utilitarianism, deontology) and apply them to real-world technology dilemmas.

Students analyze the societal impact of social media, focusing on issues like misinformation, online harassment, and digital citizenship.

Students investigate the environmental footprint of computing, from energy consumption of data centers to electronic waste.

Students initiate their capstone project, focusing on requirements gathering, project scope, and initial design.

Students implement scrum and sprint methodologies to manage a project, learning to use version control systems like Git.

Students apply design thinking principles to create intuitive user interfaces, conducting usability testing.

Students write comprehensive test plans and perform unit and integration testing to ensure software reliability.

Students create technical documentation for their software and explore deployment strategies.