Nanodegree key: nd013
Version: 5.0.0
Locale: enus
Work on the future of autonomous vehicles and help make the selfdriving car revolution a reality!
Content
Part 01 : Computer Vision, Deep Learning, and Sensor Fusion
Here, you'll first become an expert in applying Computer Vision and Deep Learning on automotive problems. You will teach the car to detect lane lines, predict steering angle, and more all based on just camera data, along with working with lidar and radar data later on.

Module 01:
Introduction

Lesson 01: Introduction
Welcome! Get an introduction to the program, discover the services we provide, and get a sneakpeek at the incredible projects you'll build!
 Concept 01: Why SelfDriving Cars?
 Concept 02: Meet Your Instructors
 Concept 03: Overview of ND Program
 Concept 04: What Projects Will You Build?
 Concept 05: Access the Career Portal
 Concept 06: Community Code of Conduct
 Concept 07: Rating Your Career Confidence
 Concept 08: SelfDriving Car History
 Concept 09: The Great Robot Race (Optional)
 Concept 10: SelfDriving Car Quiz
 Concept 11: C++ Readiness

Lesson 02: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.

Lesson 03: Knowledge, Community, and Careers
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.


Module 02:
Computer Vision

Lesson 01: Computer Vision Fundamentals
Get a taste of some basic computer vision techniques to find lane markings on the road.
 Concept 01: Power of Cameras
 Concept 02: Setting up the Problem
 Concept 03: Color Selection
 Concept 04: Color Selection Code Example
 Concept 05: Color Selection
 Concept 06: Region Masking
 Concept 07: Color and Region Combined
 Concept 08: Color Region
 Concept 09: Finding Lines of Any Color
 Concept 10: What is Computer Vision?
 Concept 11: Canny Edge Detection
 Concept 12: Canny to Detect Lane Lines
 Concept 13: Canny Edges
 Concept 14: Hough Transform
 Concept 15: Hough Transform to Find Lane Lines
 Concept 16: Hough Transform
 Concept 17: Parameter Tuning

Lesson 02: Project: Finding Lane Lines
Write code to identify lane lines on the road, first in an image, and later in a video stream.

Lesson 03: Camera Calibration
Learn how to calibrate your camera to remove inherent distortions that can affect its perception of the world.
 Concept 01: The Challenges with Cameras
 Concept 02: Welcome to Computer Vision
 Concept 03: Overview
 Concept 04: Getting Started
 Concept 05: Distortion Correction
 Concept 06: Effects of Distortion
 Concept 07: Pinhole Camera Model
 Concept 08: Image Formation
 Concept 09: Measuring Distortion
 Concept 10: Finding Corners
 Concept 11: Calibrating Your Camera
 Concept 12: Correcting for Distortion
 Concept 13: Lane Curvature
 Concept 14: Perspective Transform
 Concept 15: Curvature and Perspective
 Concept 16: Transform a Stop Sign
 Concept 17: Intuitions
 Concept 18: Undistort and Transform
 Concept 19: How I Did It
 Concept 20: Coming Up

Lesson 04: Gradients and Color Spaces
Learn how to use gradient thresholds and different color spaces to more easily identify lane markings on the road.
 Concept 01: Gradient Threshold
 Concept 02: Sobel Operator
 Concept 03: Applying Sobel
 Concept 04: Magnitude of the Gradient
 Concept 05: Direction of the Gradient
 Concept 06: Combining Thresholds
 Concept 07: Color Spaces
 Concept 08: Color Thresholding
 Concept 09: HLS intuitions
 Concept 10: HLS and Color Thresholds
 Concept 11: HLS Quiz
 Concept 12: Color and Gradient

Lesson 05: Advanced Computer Vision
Discover more advanced computer vision techniques to improve upon your lane lines algorithm!
 Concept 01: Reviewing Steps
 Concept 02: Processing Each Image
 Concept 03: Finding the Lines: Histogram Peaks
 Concept 04: Finding the Lines: Sliding Window
 Concept 05: Finding the Lines: Search from Prior
 Concept 06: Measuring Curvature I
 Concept 07: Measuring Curvature II
 Concept 08: Bonus Round: Computer Vision [Optional]

Lesson 06: Project: Advanced Lane Finding
Write a software pipeline to identify the lane boundaries in a video from a frontfacing camera on a car.


Module 03:
Deep Learning

Lesson 01: Neural Networks
Build and train neural networks from linear and logistic regression to backpropagation and multilayer perceptron networks.
 Concept 01: Neural Network Intuition
 Concept 02: Introduction to Deep Learning
 Concept 03: Starting Machine Learning
 Concept 04: A Note on Deep Learning
 Concept 05: Quiz: Housing Prices
 Concept 06: Solution: Housing Prices
 Concept 07: Linear to Logistic Regression
 Concept 08: Classification Problems 1
 Concept 09: Classification Problems 2
 Concept 10: Linear Boundaries
 Concept 11: Higher Dimensions
 Concept 12: Perceptrons
 Concept 13: Perceptrons II
 Concept 14: Why "Neural Networks"?
 Concept 15: Perceptrons as Logical Operators
 Concept 16: Perceptron Trick
 Concept 17: Perceptron Algorithm
 Concept 18: Error Functions
 Concept 19: Logloss Error Function
 Concept 20: Discrete vs Continuous
 Concept 21: Softmax
 Concept 22: OneHot Encoding
 Concept 23: Maximum Likelihood
 Concept 24: Maximizing Probabilities
 Concept 25: CrossEntropy 1
 Concept 26: CrossEntropy 2
 Concept 27: MultiClass Cross Entropy
 Concept 28: Logistic Regression
 Concept 29: Gradient Descent
 Concept 30: Gradient Descent: The Code
 Concept 31: Perceptron vs Gradient Descent
 Concept 32: Continuous Perceptrons
 Concept 33: Nonlinear Data
 Concept 34: NonLinear Models
 Concept 35: Neural Network Architecture
 Concept 36: Feedforward
 Concept 37: Multilayer Perceptrons
 Concept 38: Backpropagation
 Concept 39: Further Reading

Lesson 02: TensorFlow
The Principal Scientist at Google Brain introduces you to deep learning and Tensorflow, Google's deep learning framework.
 Concept 01: Deep Learning Frameworks
 Concept 02: Introduction to Deep Neural Networks
 Concept 03: What is Deep Learning?
 Concept 04: Solving Problems  Big and Small
 Concept 05: Let's Get Started!
 Concept 06: Installing TensorFlow
 Concept 07: Hello, Tensor World!
 Concept 08: Quiz: Tensorflow Input
 Concept 09: Quiz: Tensorflow Math
 Concept 10: Transition to Classification
 Concept 11: Supervised Classification
 Concept 12: Let's make a deal
 Concept 13: Training Your Logistic Classifier
 Concept 14: TensorFlow Linear Function
 Concept 15: Quiz: Linear Function
 Concept 16: Linear Update
 Concept 17: Quiz: Softmax
 Concept 18: Quiz: TensorFlow Softmax Workspaces
 Concept 19: OneHot Encoding
 Concept 20: Quiz: OneHot Encoding
 Concept 21: Cross Entropy
 Concept 22: Minimizing Cross Entropy
 Concept 23: Practical Aspects of Learning
 Concept 24: Quiz: Numerical Stability
 Concept 25: Normalized Inputs and Initial Weights
 Concept 26: Measuring Performance
 Concept 27: Transition: Overfitting > Dataset Size
 Concept 28: Validation and Test Set Size
 Concept 29: Validation Set Size
 Concept 30: Validation Test Set Size Continued
 Concept 31: Optimizing a Logistic Classifier
 Concept 32: Stochastic Gradient Descent
 Concept 33: Momentum and Learning Rate Decay
 Concept 34: Parameter Hyperspace!
 Concept 35: Minibatch
 Concept 36: Quiz 2: Minibatch
 Concept 37: Epochs
 Concept 38: Intro TensorFlow Neural Network
 Concept 39: Lab: Neural Network Workspaces

Lesson 03: Deep Neural Networks
Learn how to go from a simple neural network to a deep neural network.
 Concept 01: Let's Go Deeper
 Concept 02: Intro to Deep Neural Networks
 Concept 03: Number of Parameters
 Concept 04: Linear Models are Limited
 Concept 05: Rectified Linear Units
 Concept 06: Network of ReLUs
 Concept 07: 2Layer Neural Network
 Concept 08: Quiz: TensorFlow ReLu
 Concept 09: No Neurons
 Concept 10: The Chain Rule
 Concept 11: Backprop
 Concept 12: Deep Neural Network in TensorFlow
 Concept 13: Training a Deep Learning Network
 Concept 14: Save and Restore TensorFlow Models
 Concept 15: Finetuning
 Concept 16: Regularization Intro
 Concept 17: Regularization
 Concept 18: Regularization Quiz
 Concept 19: Dropout
 Concept 20: Dropout Pt. 2
 Concept 21: Quiz: TensorFlow Dropout
 Concept 22: Quiz 2: TensorFlow Dropout

Lesson 04: Convolutional Neural Networks
Learn the theory behind Convolutional Neural Networks and how they help us dramatically improve performance in image classification.
 Concept 01: CNNs Have Taken Over
 Concept 02: Intro To CNNs
 Concept 03: Color
 Concept 04: Statistical Invariance
 Concept 05: Convolutional Networks
 Concept 06: Intuition
 Concept 07: Filters
 Concept 08: Feature Map Sizes
 Concept 09: Convolutions continued
 Concept 10: Parameters
 Concept 11: Quiz: Convolution Output Shape
 Concept 12: Solution: Convolution Output Shape
 Concept 13: Quiz: Number of Parameters
 Concept 14: Solution: Number of Parameters
 Concept 15: Quiz: Parameter Sharing
 Concept 16: Solution: Parameter Sharing
 Concept 17: Visualizing CNNs
 Concept 18: TensorFlow Convolution Layer
 Concept 19: Explore The Design Space
 Concept 20: TensorFlow Max Pooling
 Concept 21: Quiz: Pooling Intuition
 Concept 22: Solution: Pooling Intuition
 Concept 23: Quiz: Pooling Mechanics
 Concept 24: Solution: Pooling Mechanics
 Concept 25: Quiz: Pooling Practice
 Concept 26: Solution: Pooling Practice
 Concept 27: Quiz: Average Pooling
 Concept 28: Solution: Average Pooling
 Concept 29: 1x1 Convolutions
 Concept 30: Inception Module
 Concept 31: Convolutional Network in TensorFlow
 Concept 32: TensorFlow Convolutional Layer Workspaces
 Concept 33: Solution: TensorFlow Convolution Layer
 Concept 34: TensorFlow Pooling Layer Workspaces
 Concept 35: Solution: TensorFlow Pooling Layer
 Concept 36: Lab: LeNet in TensorFlow
 Concept 37: LeNet Lab Workspace
 Concept 38: CNNs  Additional Resources

Lesson 05: LeNet for Traffic Signs
Using the infamous LeNet neural network architecture, take your first steps toward building a Traffic Sign classifier!
 Concept 01: Introduction
 Concept 02: LeNet Architecture
 Concept 03: LeNet Data
 Concept 04: LeNet Implementation
 Concept 05: LeNet Training Pipeline
 Concept 06: LeNet Evaluation Pipeline
 Concept 07: LeNet Training the Model
 Concept 08: LeNet Testing
 Concept 09: LeNet for Traffic Signs
 Concept 10: Visualizing Layers

Lesson 06: Project: Traffic Sign Classifier
Put your skills to the test by using deep learning to classify different traffic signs!

Lesson 07: Keras
Take on the neural network framework, Keras! Build and train neural networks more easily.
 Concept 01: Deep Learning Breakthroughs
 Concept 02: Introduction
 Concept 03: Deep Learning Frameworks
 Concept 04: High Level Frameworks
 Concept 05: Keras Overview
 Concept 06: Neural Networks in Keras
 Concept 07: Convolutions in Keras
 Concept 08: Pooling in Keras
 Concept 09: Dropout in Keras
 Concept 10: Testing in Keras
 Concept 11: Conclusion

Lesson 08: Transfer Learning
Learn about some of the most famous neural network architectures, and how you can use them to create new models by leveraging existing canonical networks.
 Concept 01: Introduction
 Concept 02: Bryan Catanzaro
 Concept 03: GPU vs. CPU
 Concept 04: Transfer Learning
 Concept 05: Deep Learning History
 Concept 06: ImageNet
 Concept 07: AlexNet
 Concept 08: AlexNet Today
 Concept 09: VGG
 Concept 10: Empirics
 Concept 11: GoogLeNet
 Concept 12: ResNet
 Concept 13: Without Pretrained Weights
 Concept 14: Lab: Transfer Learning
 Concept 15: Outro
 Concept 16: Bonus Round: Deep Learning [Optional]

Lesson 09: Project: Behavioral Cloning
Train a deep neural network to drive a car like you!
 Concept 01: Vehicle Simulator
 Concept 02: Intro to Behavioral Cloning Project
 Concept 03: Project Resources
 Concept 04: Running the Simulator
 Concept 05: Data Collection Tactics
 Concept 06: Data Collection Strategies
 Concept 07: Data Visualization
 Concept 08: Training Your Network
 Concept 09: Running Your Network
 Concept 10: Data Preprocessing
 Concept 11: More Networks
 Concept 12: Data Augmentation
 Concept 13: Using Multiple Cameras
 Concept 14: Cropping Images in Keras
 Concept 15: Even More Powerful Network
 Concept 16: More Data Collection
 Concept 17: Visualizing Loss
 Concept 18: Generators
 Concept 19: Recording Video in Autonomous Mode
 Concept 20: Project Workspace Instructions
 Concept 21: Project Behavioral Cloning
 Concept 22: Share your success  Behavioral Cloning


Module 04:
GitHub Lesson

Lesson 01: GitHub
Build a GitHub Profile on par with senior software engineers.
 Concept 01: Introduction
 Concept 02: GitHub profile important items
 Concept 03: Good GitHub repository
 Concept 04: Interview with Art  Part 1
 Concept 05: Identify fixes for example “bad” profile
 Concept 06: Quick Fixes #1
 Concept 07: Quick Fixes #2
 Concept 08: Writing READMEs with Walter
 Concept 09: Interview with Art  Part 2
 Concept 10: Commit messages best practices
 Concept 11: Reflect on your commit messages
 Concept 12: Participating in open source projects
 Concept 13: Interview with Art  Part 3
 Concept 14: Participating in open source projects 2
 Concept 15: Starring interesting repositories
 Concept 16: Next Steps


Module 05:
Sensor Fusion

Lesson 01: Sensors
Meet the team at Mercedes who will help you track objects in realtime with Sensor Fusion.

Lesson 02: Kalman Filters
Sebastian Thrun will walk you through the usage and concepts of a Kalman Filter using Python.
 Concept 01: Introduction
 Concept 02: Tracking Intro
 Concept 03: Gaussian Intro
 Concept 04: Variance Comparison
 Concept 05: Preferred Gaussian
 Concept 06: Evaluate Gaussian
 Concept 07: Maximize Gaussian
 Concept 08: Measurement and Motion
 Concept 09: Shifting the Mean
 Concept 10: Predicting the Peak
 Concept 11: Parameter Update
 Concept 12: Parameter Update 2
 Concept 13: Separated Gaussians
 Concept 14: Separated Gaussians 2
 Concept 15: New Mean and Variance
 Concept 16: Gaussian Motion
 Concept 17: Predict Function
 Concept 18: Kalman Filter Code
 Concept 19: Kalman Prediction
 Concept 20: Kalman Filter Land
 Concept 21: Kalman Filter Prediction
 Concept 22: Another Prediction
 Concept 23: More Kalman Filters
 Concept 24: Kalman Filter Design
 Concept 25: Kalman Matrices
 Concept 26: Conclusion

Lesson 03: C++ Checkpoint
Are you ready to build Kalman Filters with C++? Take these quizzes to find out!
 Concept 01: High Performance Computing
 Concept 02: [Optional] Beta Test our Upcoming C++ Course
 Concept 03: Challenge 1
 Concept 04: Challenge 1 Solution
 Concept 05: Challenge 2
 Concept 06: Challenge 2 Solution
 Concept 07: Challenge 3
 Concept 08: Challenge 3 Solution
 Concept 09: Challenge 4
 Concept 10: Challenge 4 Solution
 Concept 11: Challenge 5
 Concept 12: Challenge 5 Solution
 Concept 13: Outro and Advice

Lesson 04: Geometry and Trigonometry Refresher
This optional content is designed to refresh knowledge of trigonometry and geometry in support of Term 1 objectives.
 Concept 01: About this Lesson
 Concept 02: Lesson Introduction
 Concept 03: Plotting Robot Motion (right angles only)
 Concept 04: Plotting Robot Motion Solution
 Concept 05: Moving at an Angle
 Concept 06: Moving at 53.13 Degrees
 Concept 07: Who Cares About 53.13 Degrees?
 Concept 08: The Power of Trigonometry
 Concept 09: Opposite, Adjacent, Hypotenuse
 Concept 10: Trigonometric Ratios
 Concept 11: Looking up Sin, Cos, and Tan
 Concept 12: Trigonometry and Vehicle Motion
 Concept 13: Solving Trig Problems
 Concept 14: Keeping Track of x and y
 Concept 15: Keeping Track of x and y (solution)
 Concept 16: Conclusion

Lesson 05: Extended Kalman Filters
Build a Kalman Filter in C++ that's capable of handling data from multiple sources.
 Concept 01: Kalman Filters in C++
 Concept 02: Intro
 Concept 03: Lesson Map and Fusion Flow
 Concept 04: Lesson Variables and Equations
 Concept 05: Estimation Problem Refresh
 Concept 06: Kalman Filter Intuition
 Concept 07: Kalman Filter Equations in C++ Part 1
 Concept 08: Kalman Filter Equations in C++ Part 2
 Concept 09: State Prediction
 Concept 10: Process Covariance Matrix
 Concept 11: Laser Measurements Part 1
 Concept 12: Laser Measurements Part 2
 Concept 13: Laser Measurements Part 3
 Concept 14: Laser Measurements Part 4
 Concept 15: Radar Measurements
 Concept 16: Mapping with a Nonlinear Function
 Concept 17: Extended Kalman Filter
 Concept 18: Multivariate Taylor Series Expansion
 Concept 19: Jacobian Matrix Part 1
 Concept 20: Jacobian Matrix Part 2
 Concept 21: EKF Algorithm Generalization
 Concept 22: Sensor Fusion General Flow
 Concept 23: Evaluating KF Performance Part 1
 Concept 24: Evaluating KF Performance 2
 Concept 25: Outro
 Concept 26: Bonus Round: Sensor Fusion [Optional]

Lesson 06: Extended Kalman Filters Project
Apply everything you've learned about Sensor Fusion by implementing an Extended Kalman Filter in C++!
 Concept 01: Back to Bayes Theorem
 Concept 02: Intro to Extended Kalman Filter Project
 Concept 03: Data File for EKF project
 Concept 04: File Structure
 Concept 05: Main.cpp
 Concept 06: Project Code
 Concept 07: Tips and Tricks
 Concept 08: Project Resources
 Concept 09: Project Instructions for workspaces
 Concept 10: Project Extended Kalman Filter GPU
 Concept 11: Project Instructions for local setup
 Concept 12: uWebSocketIO Starter Guide
 Concept 13: Environment Setup (Windows)
 Concept 14: Environment Setup (Linux)
 Concept 15: Environment Setup (Mac)
 Concept 16: Compiling and Running the Project
 Concept 17: Share your success  EKF

Part 02 : Localization, Path Planning, Control, and System Integration
Here, you'll expand on your sensor knowledge to localize and control the vehicle. You'll evaluate sensor data from camera, radar, lidar, and GPS, and use these in closedloop controllers that actuate the vehicle, finishing by combining all your skills on a real selfdriving car!

Module 01:
Localization

Lesson 01: Introduction to Localization
Meet the team that will guide you through the localization lessons!
 Concept 01: Localization Overview
 Concept 02: Lesson Introduction
 Concept 03: Localization Intuition Quiz
 Concept 04: Localization Intuition Explanation
 Concept 05: Localizing a Self Driving Car
 Concept 06: Overview of the Lessons
 Concept 07: Localization
 Concept 08: Uniform Probability Quiz
 Concept 09: Uniform Distribution
 Concept 10: Generalized Uniform Distribution
 Concept 11: Probability After Sense
 Concept 12: Compute Sum
 Concept 13: Normalize Distribution
 Concept 14: pHit and pMiss
 Concept 15: Sum of Probabilities
 Concept 16: Sense Function
 Concept 17: Normalized Sense Function
 Concept 18: Test Sense Function
 Concept 19: Multiple Measurements
 Concept 20: Lesson Breakpoint
 Concept 21: Exact Motion
 Concept 22: Move Function
 Concept 23: Inexact Motion 1
 Concept 24: Inexact Motion 2
 Concept 25: Inexact Motion 3
 Concept 26: Inexact Move Function
 Concept 27: Limit Distribution Quiz
 Concept 28: Move Twice
 Concept 29: Move 1000
 Concept 30: Sense and Move
 Concept 31: Sense and Move 2
 Concept 32: Localization Summary
 Concept 33: Formal Definition of Probability 1
 Concept 34: Formal Definition of Probability 2
 Concept 35: Formal Definition of Probability 3
 Concept 36: Bayes' Rule
 Concept 37: Cancer Test
 Concept 38: Theorem of Total Probability
 Concept 39: Coin Flip Quiz
 Concept 40: Two Coin Quiz

Lesson 02: Markov Localization
Learn the math behind localization as well as how to implement Markov localization in C++.
 Concept 01: Return to Bayes' Rule
 Concept 02: Overview
 Concept 03: Localization Posterior: Introduction
 Concept 04: Localization Posterior Explanation and Implementation
 Concept 05: Bayes' Rule
 Concept 06: Bayes' Filter For Localization
 Concept 07: Calculate Localization Posterior
 Concept 08: Initialize Belief State
 Concept 09: Initialize Priors Function
 Concept 10: Solution: Initialize Priors Function
 Concept 11: Quiz: How Much Data?
 Concept 12: How Much Data: Explanation
 Concept 13: Derivation Outline
 Concept 14: Apply Bayes Rule with Additional Conditions
 Concept 15: Bayes Rule and Law of Total Probability
 Concept 16: Total Probability and Markov Assumption
 Concept 17: Markov Assumption for Motion Model: Quiz
 Concept 18: Markov Assumption for Motion Model: Explanation
 Concept 19: After Applying Markov Assumption: Quiz
 Concept 20: Recursive Structure
 Concept 21: Lesson Breakpoint
 Concept 22: Implementation Details for Motion Model
 Concept 23: Noise in Motion Model: Quiz
 Concept 24: Noise in Motion Model: Solution
 Concept 25: Determine Probabilities
 Concept 26: Motion Model Probabiity I
 Concept 27: Motion Model Probability II
 Concept 28: Coding the Motion Model
 Concept 29: Solution: Coding the Motion Model
 Concept 30: Observation Model Introduction
 Concept 31: Markov Assumption for Observation Model
 Concept 32: Finalize the Bayes Localization Filter
 Concept 33: Bayes Filter Theory Summary
 Concept 34: Observation Model Probability
 Concept 35: Get Pseudo Ranges
 Concept 36: Solution: Get Pseudo Ranges
 Concept 37: Coding the Observation Model
 Concept 38: Solution: Coding the Observation Model
 Concept 39: Coding the Full Filter
 Concept 40: Solution: Coding the Full Filter
 Concept 41: Conclusion

Lesson 03: Motion Models
Learn about vehicle movement and motion models to predict where your car will be at a future time.
 Concept 01: Motion in Autonomy
 Concept 02: Lesson Introduction
 Concept 03: Motion Models: Bicycle Model
 Concept 04: Yaw Rate and Velocity
 Concept 05: Note on Frames of Reference
 Concept 06: Roll, Pitch and Yaw: Quiz
 Concept 07: Odometry
 Concept 08: Odometry Errors: Quiz
 Concept 09: Odometry Errors: Solution
 Concept 10: Conclusion

Lesson 04: Particle Filters
Sebastian will teach you what a particle filter is, as well as the theory and math behind the filter.
 Concept 01: Field Trip
 Concept 02: State Space
 Concept 03: Belief Modality
 Concept 04: Efficiency
 Concept 05: Exact or Approximate
 Concept 06: Particle Filters
 Concept 07: Using Robot Class
 Concept 08: Robot Class Details
 Concept 09: Moving Robot
 Concept 10: Add Noise
 Concept 11: Robot World
 Concept 12: Creating Particles
 Concept 13: Robot Particles
 Concept 14: Importance Weight
 Concept 15: Resampling
 Concept 16: Never Sampled 1
 Concept 17: Never Sampled 2
 Concept 18: Never Sampled 3
 Concept 19: New Particle
 Concept 20: Resampling Wheel
 Concept 21: Orientation 1
 Concept 22: Orientation 2
 Concept 23: Error
 Concept 24: You and Sebastian
 Concept 25: Filters
 Concept 26: 2012

Lesson 05: Implementation of a Particle Filter
Now that you know the theory, learn how to code a particle filter!
 Concept 01: Particle Filters in C++
 Concept 02: Introduction
 Concept 03: Pseudocode
 Concept 04: Initialization
 Concept 05: Program Gaussian Sampling: Code
 Concept 06: Program Gaussian Sampling: Code Solution
 Concept 07: Prediction Step
 Concept 08: Calculate Prediction Step: Quiz
 Concept 09: Calculate Prediction Step Quiz Explanation
 Concept 10: Data Association: Nearest Neighbor
 Concept 11: Nearest Neighbor Advantages and Disadvantages
 Concept 12: Update Step
 Concept 13: Calculating Error
 Concept 14: Transformations and Associations
 Concept 15: Converting Landmark Observations
 Concept 16: Quiz: Landmarks
 Concept 17: Landmarks Quiz Solution
 Concept 18: Quiz: Association
 Concept 19: Quiz: Particle Weights
 Concept 20: Particle Weights Solution
 Concept 21: Explanation of Project Code
 Concept 22: Bonus Round: Localization [Optional]

Lesson 06: Kidnapped Vehicle Project
In this project, you'll build a particle filter and combine it with a real map to localize a vehicle!


Module 02:
Path Planning

Lesson 01: Search
Learn about discrete path planning and algorithms for solving the path planning problem.
 Concept 01: Motion Planning
 Concept 02: Introduction to Path Planning
 Concept 03: About this Lesson
 Concept 04: Motion Planning
 Concept 05: Compute Cost
 Concept 06: Compute Cost 2
 Concept 07: Optimal Path
 Concept 08: Optimal Path 2
 Concept 09: Maze
 Concept 10: Maze 2
 Concept 11: First Search Program
 Concept 12: Expansion Grid
 Concept 13: Print Path
 Concept 14: A*
 Concept 15: Implement A*
 Concept 16: A* in Action
 Concept 17: Dynamic Programming
 Concept 18: Computing Value
 Concept 19: Computing Value 2
 Concept 20: Value Program
 Concept 21: Optimum Policy
 Concept 22: Left Turn Policy
 Concept 23: Planning Conclusion

Lesson 02: Prediction
Use data from sensor fusion to generate predictions about the likely behavior of moving objects.
 Concept 01: Introduction and Overview
 Concept 02: I/O Recap
 Concept 03: ModelBased vs DataDriven Approaches
 Concept 04: Which is Best?
 Concept 05: Data Driven Example  Trajectory Clustering
 Concept 06: Trajectory Clustering 2  Online Prediction
 Concept 07: Thinking about Model Based Approaches
 Concept 08: Frenet Coordinates
 Concept 09: Process Models
 Concept 10: More on Process Models
 Concept 11: Multimodal Estimation
 Concept 12: Summary of Data Driven and Model Based Approaches
 Concept 13: Overview of Hybrid Approaches
 Concept 14: Intro to Naive Bayes
 Concept 15: Naive Bayes Quiz
 Concept 16: Implement Naive Bayes C++
 Concept 17: Implement Naive Bayes C++ (solution)
 Concept 18: Conclusion

Lesson 03: Behavior Planning
Learn how to think about highlevel behavior planning in a selfdriving car.
 Concept 01: Where To
 Concept 02: Lesson Outline
 Concept 03: Understanding Output
 Concept 04: The Behavior Problem
 Concept 05: Finite State Machines
 Concept 06: Formalizing Finite State Machines
 Concept 07: FSM Intuition
 Concept 08: States for Self Driving Cars
 Concept 09: The States We'll Use
 Concept 10: Inputs to Transition Functions
 Concept 11: Behavior Planning Pseudocode
 Concept 12: Create a Cost Function  Speed Penalty
 Concept 13: Example Cost Function  Lane Change Penalty
 Concept 14: Implement a Cost Function in C++
 Concept 15: Implement a Cost Function in C++ (solution)
 Concept 16: Implement a Second Cost Function in C++
 Concept 17: Implement a Second Cost Function in C++ (solution)
 Concept 18: Cost Function Design and Weight Tweaking
 Concept 19: Cost Function Matching
 Concept 20: Scheduling Compute Time
 Concept 21: Implement Behavior Planner in C++
 Concept 22: Implement Behavior Planner in C++ (solution)
 Concept 23: Conclusion

Lesson 04: Trajectory Generation
Use C++ and the Eigen linear algebra library to build candidate trajectories for the vehicle to follow.
 Concept 01: From Behavior to Trajectory
 Concept 02: Lesson Overview
 Concept 03: The Motion Planning Problem
 Concept 04: Properties of Motion Planning Algorithms
 Concept 05: Types of Motion Planning Algorithms
 Concept 06: A* Reminder
 Concept 07: A* Reminder Solution
 Concept 08: Hybrid A* Introduction
 Concept 09: Hybrid A* Tradeoffs
 Concept 10: Hybrid A* Tradeoffs Solution
 Concept 11: Hybrid A* in Practice
 Concept 12: Hybrid A* Heuristics
 Concept 13: Hybrid A* Pseudocode
 Concept 14: Implement Hybrid A* in C++
 Concept 15: Implement Hybrid A* in C++ (solution)
 Concept 16: Environment Classification
 Concept 17: Frenet Reminder
 Concept 18: The Need for Time
 Concept 19: s, d, and t
 Concept 20: Trajectory Matching
 Concept 21: Structured Trajectory Generation Overview
 Concept 22: Trajectories with Boundary Conditions
 Concept 23: Jerk Minimizing Trajectories
 Concept 24: Derivation Overview
 Concept 25: Derivation Details 2
 Concept 26: Polynomial Trajectory Generation
 Concept 27: Implement Quintic Polynomial Solver C++
 Concept 28: Implement Quintic Polynomial Solver Solution
 Concept 29: What should be checked?
 Concept 30: Implementing Feasibility
 Concept 31: Putting it All Together
 Concept 32: Polynomial Trajectory Reading (optional)
 Concept 33: Polynomial Trajectory Generation Playground
 Concept 34: Conclusion
 Concept 35: Bonus Round: Path Planning [Optional]

Lesson 05: Project: Highway Driving
Drive a car down a highway with other cars using your own path planner!


Module 03:
Control

Lesson 01: PID Control
Learn about and how to use PID controllers with Sebastian!
 Concept 01: Intro
 Concept 02: PID Control
 Concept 03: Proportional Control
 Concept 04: Implement P Controller
 Concept 05: P Controller Solution
 Concept 06: Oscillations
 Concept 07: PD Controller
 Concept 08: PD Controller Solution
 Concept 09: Systematic Bias
 Concept 10: Is PD Enough
 Concept 11: PID implementation
 Concept 12: PID Implementation Solution
 Concept 13: Twiddle
 Concept 14: Parameter Optimization
 Concept 15: Parameter Optimization Solution
 Concept 16: Outro
 Concept 17: Bonus Round: Control [Optional]

Lesson 02: Project: PID Controller
Implement a PID controller in C++ to maneuver the vehicle around the lake race track!


Module 04:
Career Services

Lesson 01: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
 Concept 01: Get Opportunities with LinkedIn
 Concept 02: Use Your Story to Stand Out
 Concept 03: Why Use an Elevator Pitch
 Concept 04: Create Your Elevator Pitch
 Concept 05: Use Your Elevator Pitch on LinkedIn
 Concept 06: Create Your Profile With SEO In Mind
 Concept 07: Profile Essentials
 Concept 08: Work Experiences & Accomplishments
 Concept 09: Build and Strengthen Your Network
 Concept 10: Reaching Out on LinkedIn
 Concept 11: Boost Your Visibility
 Concept 12: Up Next

Lesson 02: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
 Concept 01: Prove Your Skills With GitHub
 Concept 02: Introduction
 Concept 03: GitHub profile important items
 Concept 04: Good GitHub repository
 Concept 05: Interview with Art  Part 1
 Concept 06: Identify fixes for example “bad” profile
 Concept 07: Quick Fixes #1
 Concept 08: Quick Fixes #2
 Concept 09: Writing READMEs with Walter
 Concept 10: Interview with Art  Part 2
 Concept 11: Commit messages best practices
 Concept 12: Reflect on your commit messages
 Concept 13: Participating in open source projects
 Concept 14: Interview with Art  Part 3
 Concept 15: Participating in open source projects 2
 Concept 16: Starring interesting repositories
 Concept 17: Next Steps


Module 05:
System Integration

Lesson 01: Autonomous Vehicle Architecture
Learn about the system architecture for Carla, Udacity's autonomous vehicle!
 Concept 01: Putting Everything Together
 Concept 02: Introduction
 Concept 03: The Sensor Subsystem
 Concept 04: The Perception Subsystem
 Concept 05: Perception Subsystem Components
 Concept 06: The Planning Subsystem
 Concept 07: Planning Subsystem Components
 Concept 08: The Control Subsystem
 Concept 09: On to the code!

Lesson 02: Introduction to ROS
Obtain an architectural overview of the ROS Framework and setup your own ROS environment on your computer.
 Concept 01: Communications Between Systems
 Concept 02: Introduction
 Concept 03: Welcome to ROS Essentials
 Concept 04: Build Robots with ROS
 Concept 05: Brief History of ROS
 Concept 06: Nodes and Topics
 Concept 07: Message Passing
 Concept 08: Services
 Concept 09: Compute Graph
 Concept 10: Turtlesim Overview
 Concept 11: ROS Workspace Instructions
 Concept 12: ROS Workspace
 Concept 13: Your Virtual Machine
 Concept 14: Source the ROS Environment
 Concept 15: Run Turtlesim
 Concept 16: Turtlesim Comms: List Nodes
 Concept 17: Turtlesim Comms: List Topics
 Concept 18: Turtlesim Comms: Get Topic Info
 Concept 19: Turtlesim Comms: Message Information
 Concept 20: Turtlesim Comms: Echo a Topic
 Concept 21: Recap

Lesson 03: Packages & Catkin Workspaces
Learn about ROS workspace structure, essential command line utilities, and how to manage software packages within a project.

Lesson 04: Writing ROS Nodes
Learn to write ROS Nodes in Python.
 Concept 01: Closing In
 Concept 02: Overview
 Concept 03: ROS Publishers
 Concept 04: Simple Mover
 Concept 05: Simple Mover: The Code
 Concept 06: ROS Services
 Concept 07: Arm Mover
 Concept 08: Arm Mover: The Code
 Concept 09: Arm Mover: Launch and Interact
 Concept 10: ROS Subscribers
 Concept 11: Look Away
 Concept 12: Look Away: The Code
 Concept 13: Look Away: Launch and Interact
 Concept 14: Logging
 Concept 15: Recap
 Concept 16: Outro

Lesson 05: Project: Program an Autonomous Vehicle
Run your code on Carla, Udacity's own autonomous vehicle!
 Concept 01: Have Fun!
 Concept 02: Introduction
 Concept 03: Getting Started
 Concept 04: Project Overview
 Concept 05: Waypoint Updater Node (Partial)
 Concept 06: Waypoint Updater Partial Walkthrough
 Concept 07: DBW Node
 Concept 08: DBW Walkthrough
 Concept 09: Traffic Light Detection Node
 Concept 10: Object Detection Lab
 Concept 11: Detection Walkthrough
 Concept 12: Waypoint Updater Node (Full)
 Concept 13: Full Waypoint Walkthrough
 Concept 14: Project Submission and Getting Feedback
 Concept 15: Project Workspace Instructions
 Concept 16: Capstone Project Workspace


Module 06:
Completing the Program

Lesson 01: Completing the Program
Congratulations! You've reached the end of the program! Learn how to officially complete the program and graduate.

Part 03 (Elective) : Additional Content
Find additional optional content on Unscented Kalman Filters, Model Predictive Control, Advanced Deep Learning / Semantic Segmentation, and Functional Safety here.

Module 01:
Vehicle Detection and Tracking

Lesson 01: Object Detection
In this lesson, you'll learn how to detect and track vehicles using color and gradient features and a support vector machine classifier.
 Concept 01: Intro to Vehicle Tracking
 Concept 02: Arpan and Drew
 Concept 03: Finding Cars
 Concept 04: Object Detection Overview
 Concept 05: Manual Vehicle Detection
 Concept 06: Features
 Concept 07: Feature Intuition
 Concept 08: Color Features
 Concept 09: Template Matching
 Concept 10: Template Matching Quiz
 Concept 11: Color Histogram Features
 Concept 12: Histograms of Color
 Concept 13: Histogram Comparison
 Concept 14: Color Spaces
 Concept 15: Explore Color Spaces
 Concept 16: Spatial Binning of Color
 Concept 17: Gradient Features
 Concept 18: HOG Features
 Concept 19: Data Exploration
 Concept 20: scikitimage HOG
 Concept 21: Combining Features
 Concept 22: Combine and Normalize Features
 Concept 23: Build a Classifier
 Concept 24: Labeled Data
 Concept 25: Data Preparation
 Concept 26: Train a Classifier
 Concept 27: Parameter Tuning
 Concept 28: Color Classify
 Concept 29: HOG Classify
 Concept 30: Sliding Windows
 Concept 31: How many windows?
 Concept 32: Sliding Window Implementation
 Concept 33: Multiscale Windows
 Concept 34: Search and Classify
 Concept 35: Hog Subsampling Window Search
 Concept 36: False Positives
 Concept 37: Multiple Detections & False Positives
 Concept 38: Tracking Pipeline
 Concept 39: Summary
 Concept 40: Traditional vs. Deep Learning Approach


Module 02:
Unscented Kalman Filters

Lesson 01: Unscented Kalman Filters
While Extended Kalman Filters work great for linear motion, real objects rarely move linearly. With Unscented Kalman Filters, you'll be able to accurately track nonlinear motion!
 Concept 01: Introduction
 Concept 02: The CTRV Model
 Concept 03: The CTRV Model State Vector
 Concept 04: CTRV Differential Equation
 Concept 05: CTRV Integral 1
 Concept 06: CTRV Integral 2
 Concept 07: CTRV Zero Yaw Rate
 Concept 08: CTRV Process Noise Vector
 Concept 09: CTRV Process Noise Position
 Concept 10: UKF Process Chain
 Concept 11: What Problem Does the UKF Solve?
 Concept 12: UKF Basics Unscented Transformation
 Concept 13: Generating Sigma Points
 Concept 14: Generating Sigma Points Assignment 1
 Concept 15: Generating Sigma Points Assignment 2
 Concept 16: UKF Augmentation
 Concept 17: Augmentation Assignment 1
 Concept 18: Augmentation Assignment 2
 Concept 19: Sigma Point Prediction
 Concept 20: Sigma Point Prediction Assignment 1
 Concept 21: Sigma Point Prediction Assignment 2
 Concept 22: Predicted Mean and Covariance
 Concept 23: Predicted Mean and Covariance Assignment 1
 Concept 24: Predicted Mean and Covariance Assignment 2
 Concept 25: Measurement Prediction
 Concept 26: Predict Radar Measurement Assignment 1
 Concept 27: Predict Radar Measurement Assignment 2
 Concept 28: UKF Update
 Concept 29: UKF Update Assignment 1
 Concept 30: UKF Update Assignment 2
 Concept 31: Parameters and Consistency
 Concept 32: What to Expect from the Project
 Concept 33: Story Time
 Concept 34: Outro
 Concept 35: Bonus Round: Sensor Fusion [Optional]


Module 03:
Model Predictive Control

Lesson 01: Vehicle Models
In this lesson, you'll learn about kinematic and dynamic vehicle models. We'll use these later with Model Predictive Control.
 Concept 01: Intro
 Concept 02: Vehicle Models
 Concept 03: State
 Concept 04: Building a Kinematic Model
 Concept 05: Global Kinematic Model
 Concept 06: Solution: Global Kinematic Model
 Concept 07: Following Trajectories
 Concept 08: Fitting Polynomials
 Concept 09: Solution: Fitting Polynomials
 Concept 10: Errors
 Concept 11: Dynamic Models
 Concept 12: Dynamic Models  Forces
 Concept 13: Dynamic Models  Slip Angle
 Concept 14: Dynamic Models  Slip Ratio
 Concept 15: Dynamic Models  Tire Models
 Concept 16: Actuator Constraints
 Concept 17: Outro

Lesson 02: Model Predictive Control
In this lesson, you'll learn how to frame the control problem as an optimization problem over time horizons. This is Model Predictive Control!
 Concept 01: Intro
 Concept 02: Reference State
 Concept 03: Dealing With Stopping
 Concept 04: Additional Cost Considerations
 Concept 05: Length and Duration
 Concept 06: Putting It All Together
 Concept 07: Latency
 Concept 08: Mind The Line
 Concept 09: Solution: Mind The Line
 Concept 10: Tuning MPC
 Concept 11: Outro
 Concept 12: Bonus Round: Control [Optional]


Module 04:
Advanced Deep Learning

Lesson 01: Fully Convolutional Networks
In this lesson you'll learn the motivation for Fully Convolutional Networks and how they are structured.
 Concept 01: Intro
 Concept 02: Why Fully Convolutional Networks (FCNs) ?
 Concept 03: Fully Convolutional Networks
 Concept 04: Fully Connected to 1x1 Convolution
 Concept 05: 1x1 Convolution Quiz
 Concept 06: 1x1 Convolution Quiz Solution
 Concept 07: Transposed Convolutions
 Concept 08: Transposed Convolution Quiz
 Concept 09: Transposed Convolution Quiz Solution
 Concept 10: Skip Connections
 Concept 11: FCNs In The Wild
 Concept 12: Outro

Lesson 02: Scene Understanding
In this lesson you'll be introduced to the problem of Scene Understanding and the role FCNs play.
 Concept 01: Intro
 Concept 02: Bounding Boxes
 Concept 03: Semantic Segmentation
 Concept 04: Scene Understanding
 Concept 05: IoU
 Concept 06: IOU Example
 Concept 07: IoU Quiz
 Concept 08: IOU Solution
 Concept 09: FCN8  Encoder
 Concept 10: FCN8  Decoder
 Concept 11: FCN8  Classification & Loss
 Concept 12: Object Detection Lab
 Concept 13: Outro

Lesson 03: Inference Performance
In this lesson you'll become familiar with various optimizations in an effort to squeeze every last bit of performance at inference.
 Concept 01: Intro
 Concept 02: Why Bother With Performance
 Concept 03: Semantic Segmentation Revisited
 Concept 04: Interlude: Using The AMI
 Concept 05: Freezing Graphs
 Concept 06: Graph Transforms
 Concept 07: Fusion
 Concept 08: Optimizing For Inference
 Concept 09: Reducing Precision
 Concept 10: Quantization Quiz
 Concept 11: Quantization Conversion
 Concept 12: 8bit Calculations
 Concept 13: Compilation
 Concept 14: AOT & JIT
 Concept 15: Reusing The Graph
 Concept 16: Outro


Module 05:
Functional Safety

Lesson 01: Introduction to Functional Safety
You will learn to make safer vehicles using risk evaluation and systems engineering.
 Concept 01: Introduction to the Functional Safety Module
 Concept 02: Introduction to the Lesson
 Concept 03: What is Safety?
 Concept 04: What is Functional Safety?
 Concept 05: Introduction to Identifying Hazards
 Concept 06: Sebastian and Technology Errors
 Concept 07: Introduction to Evaluating Risks
 Concept 08: Reducing Risk with Systems Engineering
 Concept 09: Introduction to ISO 26262
 Concept 10: The Full V Model
 Concept 11: Summary
 Concept 12: Sebastian Talks About SelfDriving Car Risks

Lesson 02: Functional Safety: Safety Plan
A functional safety plan is critical to any functional safety project. Here you will learn what goes into a safety plan so that you can document your own.

Lesson 03: Functional Safety: Hazard Analysis and Risk Assessment
In a hazard analysis and risk assessment, you will identify vehicular malfunctions and evaluate their risk levels. You can then derive safety goals defining how your vehicle will remain safe.
 Concept 01: Introduction
 Concept 02: Advanced Driver Assistance System
 Concept 03: Item Definition
 Concept 04: Introduction to Hazard Analysis and Risk Assessment
 Concept 05: Sebastian Discussing Hazards
 Concept 06: Situational Analysis
 Concept 07: Identification of Hazards
 Concept 08: Risk Assessment, Severity, Exposure, Controllability
 Concept 09: Automotive Safety Integrity Levels (ASIL)
 Concept 10: Safety Goals
 Concept 11: Lesson Summary

Lesson 04: Functional Safety: Functional Safety Concept
You will derive functional safety requirements from the safety goals and then add extra functionality to the system diagram. Finally you document your work, a part of functional safety.
 Concept 01: Introduction
 Concept 02: Functional Safety Analysis
 Concept 03: Functional Safety Requirements
 Concept 04: Allocation to the Architecture
 Concept 05: Architecture Refinement
 Concept 06: ASIL Inheritance
 Concept 07: ASIL Decomposition
 Concept 08: Fault Tolerant Time Interval
 Concept 09: Warning and Degradation Concept
 Concept 10: Verification and Validation Acceptance Criteria
 Concept 11: Sebastian On Requirements and Testing
 Concept 12: Summary

Lesson 05: Functional Safety: Technical Safety Concept
Once you have derived functional safety requirements, you drill down into more detail. In the technical safety concept, you refine your requirements into technical safety requirements.
 Concept 01: Introduction
 Concept 02: Deriving Technical Safety Requirements
 Concept 03: Other Types of Technical Safety Requirements
 Concept 04: Technical Safety Requirement Attributes
 Concept 05: Allocation of Requirements to System Architecture Elements
 Concept 06: Sebastian on Testing
 Concept 07: Summary

Lesson 06: Functional Safety at the Software and Hardware Levels
The last step in the vehicle safety design phase is to derive hardware and software safety requirements. In this lesson, you will derive these requirements and refine a software system architecture.
 Concept 01: Introduction
 Concept 02: V model
 Concept 03: Hardware Failure Metrics
 Concept 04: Programming Languages
 Concept 05: Software Safety Lifecycle
 Concept 06: Software Safety Requirements Lane Departure Warning
 Concept 07: Other Sources of Software Safety Requirements
 Concept 08: Freedom from Interference  Spatial
 Concept 09: Freedom from Interference  Temporal
 Concept 10: Freedom from Interference  Temporal Part 2
 Concept 11: Sebastian and Temporal Interference
 Concept 12: Freedom from Interference  Communication
 Concept 13: System Architecture Safety Design Patterns
 Concept 14: Lesson Summary
 Concept 15: Module Summary

Part 04 (Elective) : Autonomous Systems Interview
Start off with some tips on interviewing for an autonomous systems role, then watch how candidates approach their interview questions. Finish off by practicing some questions of your own!

Module 01:
Autonomous Systems Interview

Lesson 01: Autonomous Systems Interview Practice
Start off with some tips on interviewing for an autonomous systems role, then watch how candidates approach their interview questions. Finish off by practicing some questions of your own!
Project Description  Autonomous Systems Interview Practice Project
Project Rubric  Autonomous Systems Interview Practice Project
 Concept 01: Welcome to the Course!
 Concept 02: Job Titles
 Concept 03: Your Part
 Concept 04: One Piece of the Puzzle
 Concept 05: Job Descriptions
 Concept 06: Research the Company
 Concept 07: Let's Get Started
 Concept 08: Perception Engineer
 Concept 09: Perception Engineer Reflection
 Concept 10: Deep Learning Engineer
 Concept 11: Deep Learning Engineer Reflection
 Concept 12: Motion Planning Engineer
 Concept 13: Motion Planning Engineer Reflection
 Concept 14: Mapping/Localization Engineer
 Concept 15: Mapping/Localization Engineer Reflection
 Concept 16: Control Engineer
 Concept 17: Control Engineer Reflection
 Concept 18: My Own Project
 Concept 19: My Own Project Reflection
 Concept 20: Additional Resources to Consider
 Concept 21: Final Thoughts
 Concept 22: Project Instructions
 Concept 23: Perception/Sensor Questions
 Concept 24: Deep Learning Questions
 Concept 25: Motion Planning Questions
 Concept 26: Mapping/Localization Questions
 Concept 27: Control Questions
 Concept 28: General Questions

Part 05 (Elective) : Technical Interview Prep
Learn the skills technical interviewers expect you to know—efficiency, common algorithms, manipulating popular data structures, and how to explain a solution.

Module 01:
Technical Interview Prep

Lesson 01: Introduction and Efficiency
Begin the section on data structures and algorithms, including Python and efficiency practice.
 Concept 01: Course Introduction
 Concept 02: Course Outline
 Concept 03: Course Expectations
 Concept 04: Syntax
 Concept 05: Python Practice
 Concept 06: Python: The Basics
 Concept 07: Efficiency
 Concept 08: Notation Intro
 Concept 09: Notation Continued
 Concept 10: Worst Case and Approximation
 Concept 11: Efficiency Practice

Lesson 02: ListBased Collections
Learn the definition of a list in computer science, and see definitions and examples of listbased data structures, arrays, linked lists, stacks, and queues.
 Concept 01: Welcome to Collections
 Concept 02: Lists
 Concept 03: Arrays
 Concept 04: Python Lists
 Concept 05: Linked Lists
 Concept 06: Linked Lists in Depth
 Concept 07: Linked List Practice
 Concept 08: Stacks
 Concept 09: Stacks Details
 Concept 10: Stack Practice
 Concept 11: Queues
 Concept 12: Queue Practice

Lesson 03: Searching and Sorting
Explore how to search and sort with listbased data structures, including binary search and bubble, merge, and quick sort. Learn how to use recursion.
 Concept 01: Binary Search
 Concept 02: Efficiency of Binary Search
 Concept 03: Binary Search Practice
 Concept 04: Recursion
 Concept 05: Recursion Practice
 Concept 06: Intro to Sorting
 Concept 07: Bubble Sort
 Concept 08: Efficiency of Bubble Sort
 Concept 09: Bubble Sort Practice
 Concept 10: Merge Sort
 Concept 11: Efficiency of Merge Sort
 Concept 12: Merge Sort Practice
 Concept 13: Quick Sort
 Concept 14: Efficiency of Quick Sort
 Concept 15: Quick Sort Practice

Lesson 04: Maps and Hashing
Understand the concepts of sets, maps (dictionaries), and hashing. Examine common problems and approaches to hashing, and practice with examples.

Lesson 05: Trees
Learn the concepts and terminology associated with tree data structures. Investigate tree types, such as binary search trees, heaps, and selfbalancing trees.
 Concept 01: Trees
 Concept 02: Tree Basics
 Concept 03: Tree Terminology
 Concept 04: Tree Practice
 Concept 05: Tree Traversal
 Concept 06: DepthFirst Traversals
 Concept 07: Tree Traversal Practice
 Concept 08: Search and Delete
 Concept 09: Insert
 Concept 10: Binary Search Trees
 Concept 11: Binary Tree Practice
 Concept 12: BSTs
 Concept 13: BST Complications
 Concept 14: BST Practice
 Concept 15: Heaps
 Concept 16: Heapify
 Concept 17: Heap Implementation
 Concept 18: SelfBalancing Trees
 Concept 19: RedBlack Trees  Insertion
 Concept 20: Tree Rotations

Lesson 06: Graphs
Examine the theoretical concept of a graph and understand common graph terms, coded representations, properties, traversals, and paths.
 Concept 01: Graph Introduction
 Concept 02: What Is a Graph?
 Concept 03: Directions and Cycles
 Concept 04: Connectivity
 Concept 05: Graph Practice
 Concept 06: Graph Representations
 Concept 07: Adjacency Matrices
 Concept 08: Graph Representation Practice
 Concept 09: Graph Traversal
 Concept 10: DFS
 Concept 11: BFS
 Concept 12: Graph Traversal Practice
 Concept 13: Eulerian Path

Lesson 07: Case Studies in Algorithms
Explore famous computer science problems, specifically the Shortest Path Problem, the Knapsack Problem, and the Traveling Salesman Problem.

Lesson 08: Technical Interviewing Techniques
Learn about the “algorithm” for answering common technical interviewing questions. Practice and get tips for giving interviewers what they’re looking for.
 Concept 01: Interview Introduction
 Concept 02: Clarifying the Question
 Concept 03: Confirming Inputs
 Concept 04: Test Cases
 Concept 05: Brainstorming
 Concept 06: Runtime Analysis
 Concept 07: Coding
 Concept 08: Debugging
 Concept 09: Interview WrapUp
 Concept 10: Time for Live Practice with Pramp
 Concept 11: Next Steps


Module 02:
Behavioral Questions

Lesson 01: Practice Behavioral Questions
Practice answering behavioral questions and evaluate sample responses.
 Concept 01: Introduction
 Concept 02: SelfPractice: Behavioral Questions
 Concept 03: Analyzing Behavioral Answers
 Concept 04: Time When You Showed Initiative?
 Concept 05: What Motivates You at the Workplace?
 Concept 06: A Problem and How You Dealt With It?
 Concept 07: What Do You Know About the Company?
 Concept 08: Time When You Dealt With Failure?

Lesson 02: Land a Job Offer
You've practiced a lot for the interview by now. Continue practicing, and you'll ace the interview!
