# Course Schedule¶

## Software Operation¶

### Technical Question¶

- How do I install and use the industry-standard programming tools that will help me to rigorously explore data abstraction with the Python programming language?

### Next Steps¶

- All written content in and tutorials referenced by the list of proactive technical skills.

## Python Foundations¶

### Technical Question¶

- How can I use functions, variables, conditional logic, and iteration constructs, as provided by Python, to implement programs that, for instance, find out if a number is even or odd, compute a number's square, or determine if a number is divisible by another number?

### Next Steps¶

- Read chapters 1 and 2 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/python-foundations/`

with: - Check out this Engineering Effort on Integer Squaring

## Technical Concepts

**Syntax**: the structure of a programming language that defines what characters and symbols are well formed**Semantics**: the way in which a programming language associates meaning with syntactically correct programs**Notional Machine**: idealized abstraction of both computer hardware and the semantics of a computer program**Reserved Word**: a keyword in Python that has a built-in meaning and cannot be used for a variable's name**Type Checking**: automated process to confirm the compatibility of the types for both variables and operations

## Numerical Computation¶

### Technical Question¶

- How can I use functions, floating-point variables, conditional logic, and iteration constructs to implement both exhaustive and approximate approaches to compute (i) the square root of a number, (ii) the logarithm of a number, and (iii) the roots of a polynomial function?

### Next Steps¶

- Read chapter 3 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/numerical-computation/`

with: - Check out this Engineering Effort on Primality Testing
- Check out this Source Code Survey on Numerical Data

## Technical Concepts

**Numerical Approximation**: an alternative to the exact value for a function that is close enough to be useful**Floating Point**: representing a decimal value with two integers, one for significant digits and one for exponent**Binary Number**: representation of a number using only a sequence of bits, or digits that must only be 0 or 1**Quadratic Root**: value(s) of a quadratic function where it intercepts the horizontal axis**Square Root**: mathematical function that is the inverse of the square of a number

## Function Scope¶

### Technical Question¶

- How can I use Python's scoping rules and the principle of abstraction to create modularized and/or higher-order functions that are easy to understand, implement, test, and maintain?

### Next Steps¶

- Read chapter 4 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/function-scope/`

with: - Check out this Programming Project on Number Comparison
- Check out this Programming Project on Square Roots

## Technical Concepts

**Function Specification**: the assumptions and guarantees in the contract between function creator and caller**Formal Parameters**: a function's input parameter, given a name and a type in the function's declaration**Actual Parameters**: the arguments to a function that are passed into it at the function invocation point**Debugging**: the systematic process of finding out why a program does not work and then fixing it**Higher-Order Function**: general-purpose functions for problem solving that accept functions as input

## Structured Types¶

### Technical Question¶

- How can I use Python's structured types (e.g.,
`str`

,`list`

,`range`

, and`dict`

) to implement programs that efficiently store and retrieve data?

### Next Steps¶

- Read chapter 5 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/structured-types/`

with: - Check out this Engineering Effort on Fibonacci Algorithms

## Technical Concepts

**Tuple**: immutable ordered sequence that can contain elements of any type**List**: ordered sequence of values where each value is identified by an index**Set**: unordered collection of unique elements used for data storage**Dictionary**: container structure like a list, except for the fact that it is indexed with a key**Shallow Copy**: creation of a new list that involves inserting contained objects into a new list

## Program Components¶

### Technical Question¶

- How can I use different types of program components, such as recursive functions, modules, libraries, and files to implement efficient programs with effective designs?

### Next Steps¶

- Read chapters 6 and 7 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/program-components/`

with: - Check out this Engineering Effort on Intersection Algorithms

## Technical Concepts

**Recursive Function**: function that repeatedly calls itself until reaching a base case that stops recursion**Global Variable**: a variable that is accessible to all of the functions in a module**Module**: a Python file that contains definitions of variables and functions accessible to a program**Standard Library**: collection of packages available to all Python programs through an import statement**File**: disk-based storage mechanism that contains content created by humans and/or computer programs

## Software Testing¶

### Technical Question¶

- How can I use the processes of software testing and debugging to establish a confidence in the correctness of a Python program?

### Next Steps¶

- Read chapter 8 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/software-testing/`

with: - Check out this Engineering Effort on Palindrome Checking
- Check out this Source Code Survey on Debugging Functions

## Technical Concepts

**Testing**: process of running a program to try to ascertain whether or not it works as intended**Debugging**: process of trying to fix a program that does not currently work as intended**Unit Testing**: writing and running test cases designed to ensure that small units of functionality work correctly**Regression Testing**: process of re-running test cases whenever a programmer makes any program changes**Defensive Programming**: creating software to ensure that defects are overt and persistent

## Object-Oriented Programming¶

### Technical Question¶

- How can I use the principles and primitives of object-oriented programming to implement Python programs with top-notch and easy-to-understand designs?

### Next Steps¶

- Read chapters 9 and 10 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/object-oriented/`

with: - Check out this Engineering Effort on Object Processing
- Check out this Source Code Survey on Structured Types

## Technical Concepts

**Exception**: something that does not conform to the normal expectation for program behavior**Unhandled Exception**: an exception that is raised that causes the program to stop running**Try-Except Block**: key building block for exception handling in the Python pogramming language**Inheritance**: mechanism for building groups of related abstractions that establishes a parent-child relationship**Information Hiding**: the client of a class should only rely on the public methods of the class

## Algorithmic Complexity¶

### Technical Question¶

- How can I implement more efficient Python programs by conducting both an analytical and an empirical evaluation of the performance of an algorithm?

### Next Steps¶

- Read chapter 11 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/algorithmic-complexity/`

with: - Check out this Engineering Effort on Sorting Algorithms

## Technical Concepts

**Random Access Machine**: model of computation in which steps are executed sequentially one at a time**Best-Case Running Time**: minimum running time over all possible inputs of a given size**Worst-Case Running Time**: maximum running time over all possible inputs of a given size**Average-Case Running Time**: average (or, expected) running time over all possible inputs of a given size**Asymptotic Notation**: relationship between the running time of an algorithm and the size of its inputs

## Data Structures¶

### Technical Question¶

- How can I implement, use, and test data structures that support efficient data processing with searching and sorting algorithms?

### Next Steps¶

- Read chapter 12 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed
- Run the Jupyter notebooks in
`data-abstraction/algorithmic-complexity/`

with: - Check out this Source Code Survey on Container Cloning
- Check out this Engineering Effort on Containment Checking

## Technical Concepts

**Search Algorithm**: method for finding an item or a group of items in a collection of items**Search Space**: the collection of items subject to search**Indirection**: accessing something by first accessing something else that contains a reference to it**Merge Sort**: sorting algorithm that employs divide-and-conquer approach to sorting data**Stable Sorting**: process of sorting data such that the order of equal items in an input list are preserved

## Optimization Problems¶

### Technical Question¶

- How can I use algorithms to efficiently solve an optimization problem (e.g., the 0/1 knapsack problem) characterized by an objective function and a set of constraints?

### Next Steps¶

- Read chapters 14 and 15 of
*Introduction to Computation and Programming Using Python* - Check out the course slides for a detailed investigation of these chapters!
- Run the Jupyter notebooks in
`data-abstraction/optimization-problems/`

with: - Check out this Programming Project on Matrix Processing
- Check out this Source Code Survey on Optimization

## Technical Concepts

**Objective Function**: a function that is to either be maximized or minimized in order to achieve a goal**Optimization Constraints**: restrictions on the solution to an optimization problem**Knapsack Problem**: optimization problem with the goal of maximizing a benefit and minimizing a weight**Greedy Algorithm**: practical approach to solving optimization problems that chooses the next best item**Dynamic Programming**: strategy for problems that exhibit overlapping subproblems and optimal substructure

## Learning Opportunities¶

Interested in learning more about any of the topics on this schedule? If you are, then make sure to connect with members of the proactive community for more learning opportunities. Remember, this course emphasizes building mastery of the course's learning objectives through "learning by doing", as explained in the description of proactive learning. As such, you can best understand the content on this schedule by completing all the source code surveys, programming projects, and engineering efforts!

2023-08-23 Updated: 2021-08-17 Created: