combined.yaml

UseInputFunction: Use the "input" function to retrieve input from the user
UsePrintFunction: Use the "print" function to display data to the user
IdentifyPossibleProgramOutputs: Identify possible outputs of a program (printing, graphics, robots)
IdentifyPossibleProgramInputs: Identify possible inputs to a program (keyboard, mouse, files, sensors)
ExplainUseOfPrintVsDebugging: Explain the necessity of "print" vs. debugging tools

ExplainPurposeOfValues: Explain the purpose of values
IdentifyLiteralValues: Identify a literal value

ListBasicTypes: List the types
WriteBasicValues: Write syntactically correct String, Float, Integer, Boolean, and None values
IdentifyLiteralValueTypes: Identify the type of a literal value
CompareTypes: Compare and contrast types
DefineBasicTypes: Define the types
DefineTermType: Define the idea of a type

IdentifyArithmeticExpressionType: Identify the type of an arithmetic expressions
WriteArithmeticExpression: Write a mathematical expression that uses +, -, *, **, /
IdentifyArityOfArithmeticOperators: Describe the limitations of the basic operators with regards to their number of parameters

IdentifyConditionalExpressionType: Identify the type of a conditional expressions
IdentifyArityOfConditionalOperators: Describe the limitations of the basic conditional operators with regards to their number of parameters
WriteComparisonExpression: Write an equivalency expression using different equality operators
WriteConditionalOperatorExpression: Write a complex conditional with logic operators
SimplifyBooleanExpression: Simplify a boolean equivalency check

WriteCodeWithVariables: Write a program that creates/reads/updates variables
IdentifyIfNameIsValid: Identify valid and invalid names in python
IdentifyTypeOfVariable: Identify the type of a variable
DifferentiateBetweenMathProgrammingVariables: Differentiate between algebraic variables and programming variables
WriteAssignmentWithLiteralValues: Write an assignment that involves literal values
WriteAssignmentWithVariables: Write an assignment that involves variables
WriteAssignmentWithExpressions: Write an assignment that involves expressions
WriteAssignmentThatUpdatesVariable: Write an assignment that updates a variable

LocateVariables: Locate all the variables in a program
DetermineIfGoodVariableName: Determine if variable names are good
ExplainWhyNameIsBad: Use specific criteria to explain why a variable name is bad
ProposeGoodVariableName: Propose a good variable name

TraceVariablesValue: Trace the value of a variable over the execution of a program
TraceVariableCreation: Identify the lifetime (e.g., creation point) of a variable

PredictComplexProgramOutput: Predict the output of a multi-line program
PlaceStatementsInOrder: Order multiple statements correctly
DescribeSequentialExecution: Describe how programs are executed in a sequence
TraceMultipleVariablesValue: Trace the values of multiple variables in a program
IdentifyIfExpressionOrStatement: Identify an expression
IdentifyTypeOfExpression: Identify the type of an expression
WriteComplexExpressions: Write syntactically correct values that incorporate complex expressions


DefineString: Define the concept of a string
CreateStringLiteral: Create a string literal
CreateTripleStringLiteral: Create a triple-quoted string
UseEscapeCharactersInLiteral: Incorporate escape characters into a string

CombineStrings: Combine two strings
CompareStrings: Compare two strings
SubscriptCharacterFromString: Subscripting a character from a string
SubscriptRangeFromString: Subscripting a range of characters from a string
DefineIfStatement: Define an If Statement
EvaluateConditional: Evaluate a conditional expression
DetermineIfStatementNeeded: Determine whether a situation requires an If statement
WriteIfStatement: Write code that involves simple if statement

DefineTruthiness: Define the concept of Truthiness

WriteNestedIfStatement: Write code that involves nested if statements
WriteBranchingConditions: Write code with branching conditions
TracingBranchingFlow: Trace branching control flow
DifferentiateDoubleIfElif: Differentiate between double IFs and the ELIF
RetrieveStructuredDataWithRequests: Retrieve structured data from a URL algorithmically using Requests
RetrieveUnstructuredDataWithRequests: Retrieve data from a web page algorithmically using Requests
ExtractHTMLWithBeautifulSoup: Extract data from an HTML page using BeautifulSoup
ExtractDataWithRegex: Extract data from a string using Regexes
IdentifyApplicationsDownloadingData: Identify practical applications of downloading data from the internet
ListWebDataHazards: List hazards of using data through the web.

CreateVisualizations: Create visualizations of data
InterpretVisualizations: Intepret visualizations of data
ShowPlotWithMatPlotLib: Use the "show" function to correctly render plots
TransformDataForPlotting: Transform complex nested data into a form suitable for plotting
ChooseGraphType: Choose a suitable graph to answer a question

DescribeJupyterNotebooks: Describe Jupyter Notebooks
ExplainJupyterNotebookPurpose: Explain the purpose of a Jupyter Notebook
CreateJupyterNotebook: Create a Jupyter Notebook
CreateVisualizationsInJupyter: Create visualizations to be embedded in a Jupyter Notebook

DefineDataScience: Define Data Science
DescribeDataScienceWorkflow: Describe a Data Science workflow
InterpretDataScienceAnalysis: Interpret the results of a Data Science analysis
CreateDictionaryLiteral: Create a dictionary literal
DescribeDictionarySubtypes: Describe the subtypes of a dictionary
DictionaryAccess: Use dictionary access to access a literal key

IterateDictionary: Iterate through a dictionary using .keys(), .values(), and .items()
TestDictionaryMembership: Test membership within a dictionary
DictionaryMutate: Use dictionary access to change the value associated with a key

DictionaryPatternLookup: Use a dictionary to look up data
DictionaryPatternRecord: Use a dictionary as a struct/record
DictionaryPatternCount: Use a dictionary to keep track of occurrences

DefineRecordType: Define the term record type.
DefineRecordInstance: Define the term record instance.
CreateRecordType: Create a Record using a dictionary literal.

ReplaceDictionaryFindWithLookup: Replace a find operation with a lookup
CompareLookupFindDictionary: Explain the advantage of a lookup operation vs. a find operation


ExplainComplexTypeNesting: Explain how complex types can be nested
WriteListDictionaryLiterals: Write syntactically correct Lists and Dictionaries literal values
WriteComposedLiterals: Write syntactically correct literals that compose multiple types
AccessNestedData: Write statements and expressions that access data in nested data structures
DescribeComplexNestedData: Describe complex nested data in succinct forms
NavigateFileSystemWithCommandLine: Navigate a file system using the command line
IdentifyFilePath: Identify the path of a file

DefineFile: Define the term File
ExplainFileVsString: Explain the difference between a File and a String
OpenFileUsingWithBlock: Properly open and close a file using the With block
DifferentiateFilePathNameHandle: Differentiate between a File, it's name, it's path, and it's handle
ReadFileIntoMemory: Read an entire file into memory
ReadFileLineByLine: Read a file using line by line iteration

DefineModule: Define the term "Module"
ImportModule: Write code that imports a module
UseFunctionFromImportedModule: Write code that uses functions defined in an external module
CreateModule: Create a module

DefineFileFormat: Define the term "File Format"
CompareContrastJsonVsText: Compare and contrast the JSON format with a basic text format
CallWithNamedParameter: Use a named parameter to call a function
DefineTermFunction: Define the term Function
IdentifyNecessaryPartsOfFunctionCall: Identify the necessary and optional parts of a Function call
ExplainPurposeOfFunction: Explain the purpose of a Function
CompareContrastFunctionProgram: Compare and contrast a function with a program
CallFunctionWithReturn: Call a function with a return value
CallMethodWithReturn: Call a method with a return value
CallFunctionWithArgument: Call a function with an argument
CallMethodWithArgument: Call a method with an argument
CompareContrastPrintReturn: Compare and contrast printing vs. returning from a function

InterpretFunctionDocumentation: Interpret documentation for a function
UseFunctionFromDocumentation: Use a function based on its documentation
DistinguishParametersArguments: Distinguish between Parameters and Arguments
NestFunctionCalls: Nest a function call inside another function call
ChainMethods: Chain a method onto another method
CombineOperatorsFunctionsMethods: Combine functions, methods, and operators into a complex expression

DetermineIfFunctionNeeded: Determine if a situation could benefit from a function
BreakDownTaskIntoFunctionCalls: Break down a complex task into multiple function calls
IdentifyScopeOfVariable: Identify the scope of variables in and outside of a function
DefineFunctionWithReturn: Define a function with a return value
DefineFunctionWithoutParameters: Define a function without parameters
DefineFunctionWithParameters: Define a function with parameters
ExtractVariableIntoParameter: Extract a variable from a function into a parameter
DescribeFunctionSignature: Describe the signature of a function

ExplainUnitTesting: Explain how functions are tested for correctness.
ListAdvantagesOfUnitTesting: List advantages of using unit tests
InterpretFailingUnitTest: Intepret a failing unit test
DescribeLimitationsOfUnitTests: Describe the limitations of unit tests

DifferentiateReturnPrint: Differentiate between a return statement and a print function
PredictImplicitReturnValue: Identify the output of a function that does not return anything
PredictReturnValueFromPrint: Identify the output of a function that prints instead of returns
IdentifyCallsite: Identify a callsite

DetermineAvailabilityOfVariableInFunction: Determine whether a variable is available within a function.
DetermineIfVariableIsAvailableOutsideFunction: Determine whether a variable is available outside a function.
DetermineIfVariableAliasedWithinFunction: Determine whether a variable is aliased within a function.
DistinguishGlobalLocalVariable: Define the difference between a global variable and a local variable.
ExplainGlobalVariablesAreBad: Explain why global variables are bad.

CreateSingleLineComment: Create a single-line comment
CreateMultiLineComment: Create a multi-line comment
DistinguishSingleMultiLineComment: Differentiate between a single- and multi- line comment
ExplainLimitationsOfMultiLineComment: Explain the limitation of multi-line comments
ExplainDocumentationPurpose: Explain the purpose of documentation
DocumentFunction: Document a function's inputs, outputs, and purpose

DefineFunctionsToSolveProblems: Use functions to solve problems
EvaluateNameOfFunction: Evaluate the name of a function
ExtractCodeIntoFunction: Extract code into a function
DefineFunctionalDecomposition: Define functional decomposition

DescribeChainedFunctionDataFlow: Describe how data flows between two chained functions.
ExplainInterFunctionValueFlow: Explain how values defined in one function can flow to another function.
DescribeUserInputIntroducesValuesIntoFlow: Describe how user input introduces new values
DefineForLoop: Define a For Loop and Iteration Variable for an Iteration List
ChooseIterationVariable: Construct an Iteration Variable for an Iteration List
UseForLoopOnListValue: Write code that involves iteration over a list value
UseForLoopOnListVariable: Write code that involves iteration over a list variable
DetermineIterationVariableType: Identify the type of the iteration variable with respect to the iteration list
DetermineIfForLoopNecessary: Determine if a situation requires a For loop

ListForLoopPatterns: List the common patterns associated with FOR loops
MatchLoopPatternToProblem: Match a problem with the associated loop pattern
UseMapLoopPattern: Use the Map pattern of FOR loops to transform a list
UseFilterLoopPattern: Use the Filter pattern of FOR loops to remove elements from a list
UseSumLoopPattern: Use the Sum pattern of FOR loops to summate a list of integers
UseCountLoopPattern: Use the Count pattern of FOR loops to count the length of a list
UseAccumulateLoopPattern: Use the Accumulate pattern of FOR loops to combine elements of a list
UseMinMaxLoopPattern: Use the Min/Max pattern of FOR loops to find the highest or lowest element of a list
UseFindLoopPattern: Use the Find pattern of FOR loops to find an element in a list based on a condition
UseTakeLoopPattern: Use the Take pattern of FOR loops to take elements in a list until a condition is met
ModifyLoopPattern: Modify a loop pattern to solve a problem

DefineMutability: Define the term Mutability
DifferentiateListAppendAdd: Differentiate list appending from string addition
ExplainListAppendAssignment: Explain the result of assigning the result of list appending to the list variable

StringIteration: Iterate through a string
ProcessStringForLoop: Process a String with a FOR loop
DifferentiateListString: Differentiate between a list and a string

ListIndexIteration: Iterate through a list by its indexes
ListIndexIterationTradeOffs: List trade-offs of iterating through a list by indexes

CompareForWhileLoops: Compare and contrast the For loop and While loop
DefineWhileLoop: Define a While loop
DetermineIfWhileLoopNeeded: Determine if a situation requires a While loop
WriteConditionalIteration: Write code that involves condition based iteration

DefineControlStructure: Define control structure
IdentifyControlStructures: Identify control structures in code
DescribeControlFlow: Describe the impact of various control structures on the sequence of a program.
NestControlStructures: Nest control structures
DefineProgrammingLanguage: Define the term "programming language"
DifferentiateSyntaxSemantics: Describe the difference between syntax and semantics
DefineExecute: Explain the meaning of the terms "run" and "execute"
DefineCompositeType: Define the term "Composite Type"
CreateListLiteral: Create a list literal
IdentifyListElementType: Identify the element type of a list
DifferentiateEmptyFilledLists: Differentiate between lists and empty lists

SubscriptList: Subscript an element from a list
SliceList: Subscript a slice within a list
ExplainZeroBasedIndexList: Explain the nature of zero-based indexing
AppendList: Append an element to a list
PopList: Pop an element from a list
UseRangeCreateList: Create a list using range()
DescribeMajorCourseConcepts: Describe major course concepts and policies
UseCanvas: Use the Canvas site to access course materials
DefineProgramming: Define "programming"
ExplainProgrammingUseful: Explain why programming is useful
IdentifyProgrammingLimitations: Identify limitations of programming
EnumerateProgramComponents: Enumerate the core components of programs
WriteSimpleProgram: Write simple programs
ListCommonMisconceptionsLearningProgramming: List common misconceptions about learning.
ListBestStrategiesForLearningProgramming: List best strategies for learning to program.
AssessPriorProgrammingKnowledge: Assess prior knowledge of programming
CommunicateProfessionally: Seek help by communicating desired functionality, approach, perceived problems, current code, and specific errors.
ExplainErrorMessageByType: Explain an error message for different types of errors
RecallSimilarityErrorException: Recall the similarity in the terms "Error" and "Exception"
IdentifyLineOfErrorMessage: Track down the offending line of an error message
SuggestSolutionToErrorMessage: Choose an appropriate solution to the error message
IdentifyLineOfErrorMessageInTraceback: Track down the offending line of an error message in a called function of an external module

ChooseDebuggingMethod: Choose the most suitable debugging method to debug a program
CompareContrastDebuggingTechniques: Compare and contrast different debugging techniques
ExplainHowAutomaticTracingDebug: Explain how you can use automatic tracing tools to debug a program
ExplainHowPrintDebugging: Explain how you can use print debugging to debug a program
ExplainHowManualTracingDebugging: Explain how you can use code tracing to debug a program
ExplainHowGoogleDebugging: Explain how you can google to debug a program
ExplainRubberDuckDebugging: Explain how you can use rubber duck debugging
InstallThonny: Install Thonny on your laptop.
UseThonny: Use Thonny to run a Python program.
UseBlockPy: Use BlockPy to run a Python program.