Computer Science & Systems

This concept introduces how organizations standardize security using frameworks like **NIST** 800‑171 and the Cybersecurity Maturity Model Certification (CMMC).[page:1][page:2]

In CS 101, the goal is not for you to memorize every control, but to see how technical decisions (passwords, access, logging) connect to written rules and real‑world responsibilities.[page:1][page:2]

• Recognize the purpose of a security framework in managing risk.
• Connect basic security controls to everyday computing scenarios.
• See how policy, people, and technology form one system.

Accuracy testing compares an algorithm’s output against known “correct” answers to make sure the logic is working as expected.[page:1]

In CS 101, you will think like a tester: design simple test cases, predict outputs, and decide whether the algorithm passes or fails.

• Define a test case and expected result.
• Explain why accuracy matters in real applications (e.g., grading, medical devices, navigation).
• Practice debugging when results do not match expectations.

Activity logs record events such as logins, file changes, and errors so that administrators can understand what happened on a system.[page:1]

For introductory CS, logs are a window into how software and users interact, and they are a powerful tool for troubleshooting.

• Identify common log entries (time, user, action, status).
• Describe how logs support debugging and security investigations.
• Relate logs to your own experience (e.g., browser history, phone notifications).

An array is a container that holds multiple values of the same type, indexed starting at position 0 in many languages.[page:1]

You will use arrays to group related data (such as grades or sensor readings) so algorithms can loop over them efficiently.

• Explain how index positions map to elements.
• Distinguish between the length of an array and its largest valid index.
• Trace simple loops that read or modify array elements.

A command line interface (CLI) lets you type commands to navigate folders, manage files, and run programs without a graphical desktop.[page:1]

Learning a few foundational commands builds confidence with operating systems and prepares you for scripting and automation.

• Recognize basic commands for navigation, listing, and file operations.
• Interpret command syntax: command, options, and arguments.
• Practice reading help text and manual pages.

Conditions allow a program to choose between different paths based on whether a Boolean expression is true or false.[page:1]

Everyday decisions (“If it is raining, take an umbrella”) map directly to if/else statements in code.

• Write simple conditional expressions using comparison operators.
• Trace if/else branches and predict outcomes.
• Identify common pitfalls such as using “=” instead of “==”.

A function is a reusable block of code that takes inputs, performs a task, and optionally returns a result.[page:1]

Thinking of a function as a “machine” helps: values go in, the machine works, and an output comes back.

• Identify function names, parameters, and return values.
• Explain why functions improve readability and reusability.
• Trace how data flows in and out of a function call.

Linux is a family of open‑source operating systems used in servers, cloud platforms, phones, and embedded devices.[page:1]

Understanding Linux introduces you to key system concepts such as processes, permissions, and file systems.

• Recognize common Linux distributions and use cases.
• Explore basic Linux commands and directory structure.
• Compare Linux with other operating systems you already know.

Loops let a program repeat instructions until a condition is met, such as processing each item in a list.[page:1]

Many algorithms are built by combining loops with arrays and conditions.

• Differentiate between while, for, and do/while loops.
• Identify loop control variables and stopping conditions.
• Spot infinite loops and off‑by‑one errors.

Operators such as +, −, *, /, %, ==, >, and && let programs perform arithmetic and make logical comparisons.[page:1]

Understanding how expressions are evaluated is essential for writing clear conditions and calculations.

• Recognize arithmetic, comparison, and logical operators.
• Evaluate compound expressions step by step.
• Predict how precedence and grouping affect results.

An academic plan is a structured roadmap that connects your goals, required courses, and timelines into one system.[page:1]

Thinking like a systems engineer can help you anticipate bottlenecks, prerequisites, and backup paths.

• Map CS 101 to later courses or career goals.
• Identify constraints such as time, workload, and sequencing.
• Adjust the plan as new information or opportunities appear.

Data structures are patterns for organizing data so algorithms can access and update it efficiently.[page:1]

In this course you will compare simple structures—arrays, lists, stacks, and queues—using everyday analogies (shopping lists, plates, lines).

• Describe basic operations: insert, remove, access.
• Explain “last in, first out” (LIFO) and “first in, first out” (FIFO).
• Match real‑world scenarios to appropriate data structures.

A variable is a named storage location that holds a value your program can read or change while it runs.[page:1]

Good variable names make code easier to understand and maintain.

• Declare variables and assign values.
• Distinguish between different data types.
• Predict how variable values change as code executes.

Flashcards help you move core vocabulary and concepts into long‑term memory through quick recall practice.

Use the flashcards throughout the term to review variables, loops, conditions, and data structures.

• Self‑test before quizzes or exams.
• Track which topics you answer quickly versus those that need more review.
• Combine flashcards with this portal to revisit weak areas.

Software testing is the process of planning and running tests to uncover bugs and verify that requirements are met.[page:1]

In CS 101, you will connect testing ideas to the code you write: unit tests for single functions and scenario tests for whole features.

• Differentiate between unit, integration, and system tests.
• Explain why early testing reduces cost and risk.
• Design basic test cases for a small program or algorithm.