Nanodegree key: nd001
Version: 9.0.0
Locale: en-us
Become a Front-End Web Developer by completing a variety of projects for your portfolio - become an HTML, CSS and JavaScript pro!
Content
Part 01 : Welcome to the Program!
Welcome to the Front-End Web Developer Nanodegree program. This is your first step on your journey to become a Front-End programmer. Learn what this program is all about as well as how to find support along your learning journey.
-
Module 01: Orientation
-
Lesson 01: Nanodegree Orientation
Welcome to the Front-End Web Developer Nanodegree program! In this short lesson, we'll introduce you to what it means to be a web developer, and the features of your Nanodegree program!
-
Lesson 02: Nanodegree Career Services
The Careers team at Udacity is here to help you move forward in your career - whether it's finding a new job, exploring a new career path, or applying new skills to your current job.
-
-
Module 02: How to Get Help from Peers and Mentors
-
Lesson 01: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
-
Part 02 : The Building Blocks of Front-End Development
In this section, you'll be building a portfolio website. You will be provided a design mockup as a PDF-file, and you must replicate that design in HTML and CSS. You will develop a responsive website that will display images, descriptions and links to each of the portfolio projects you will complete through the course of your Nanodegree program on any size of screen.
-
Module 01: HTML & CSS Practice
-
Lesson 01: HTML Syntax
Set up your development environment for writing HTML and learn basic tags and syntax.
- Concept 01: Lesson Introduction
- Concept 02: HTML Structure Part 1
- Concept 03: Make Your First Element
- Concept 04: Environments
- Concept 05: Text Editors
- Concept 06: Browsers
- Concept 07: Workflow
- Concept 08: Trees
- Concept 09: HTML and Trees
- Concept 10: Spot the Bug
- Concept 11: HTML Research
- Concept 12: HTML Structure Part 2
- Concept 13: HTML Documents in Depth
- Concept 14: Lesson Wrap Up
-
Lesson 02: HTML Syntax Problem Set
Get practice creating HTML documents and writing tags with this collection of fun challenges.
- Concept 01: Welcome to the Problem Set!
- Concept 02: Make a Button
- Concept 03: Make a Button Solution
- Concept 04: Make All the Headers
- Concept 05: Make a List
- Concept 06: Tree to HTML
- Concept 07: Constructing Links
- Concept 08: Add an Image
- Concept 09: A Guide to Paths
- Concept 10: Figures
- Concept 11: Mockup to Website
-
Lesson 03: CSS Syntax
Learn the basics of CSS syntax and get started adding style to your websites.
- Concept 01: Getting Started with CSS
- Concept 02: What is CSS?
- Concept 03: CSS or HTML?
- Concept 04: CSS Rulesets
- Concept 05: CSS Syntax
- Concept 06: Comments
- Concept 07: Tag Selectors
- Concept 08: Attributes and Selectors
- Concept 09: Using Selectors
- Concept 10: Using CSS References
- Concept 11: Developer Tools
- Concept 12: Developer Tools on Different Browsers
- Concept 13: Quiz: Using Developer Tools
- Concept 14: CSS Units
- Concept 15: Units in CSS
- Concept 16: CSS Colors
- Concept 17: Identifying Colors
- Concept 18: Outro
-
Lesson 04: CSS Syntax Problem Set
Practice writing CSS and styling websites while exploring new properties in this problem set.
- Concept 01: Welcome to the Problem Set!
- Concept 02: Style an Image
- Concept 03: Style the Font
- Concept 04: Writing Selectors
- Concept 05: Using Attributes
- Concept 06: Attributes Workspace
- Concept 07: Slack Card
- Concept 08: Slack Card Workspace
- Concept 09: Udacity Site Header
- Concept 10: Udacity Site Header Workspace
- Concept 11: What is a Stylesheet?
- Concept 12: Link to a Stylesheet
-
Lesson 05: How to Write Code Faster
Learn tips, tricks, and shortcuts to improve your developer workflow and customize your code editor with packages and themes.
- Concept 01: Writing Code Faster
- Concept 02: Sublime Text and Atom Keyboard Shortcuts
- Concept 03: Practice Keyboard Shortcuts
- Concept 04: Keyboard Shortcuts
- Concept 05: Extending Sublime Text and Atom
- Concept 06: Installing Packages and Themes
- Concept 07: Recommended Packages
- Concept 08: Recommended Themes
- Concept 09: What’s Your Favorite Theme?
- Concept 10: Coder, Better, Tooler, Hacker
-
-
Module 02: Responsive Design
-
Lesson 01: Why Responsive?
Explore the case for responsive design. You'll see how the experience of using the web changes from one device type to another.
- Concept 01: Sites On Mobile
- Concept 02: Intro to Project
- Concept 03: Pan, Zoom, Touch, Ick
- Concept 04: Emulators, Simulators and Real Devices
- Concept 05: Setting up Chrome's Dev Tools
- Concept 06: Remote Debugging Intro
- Concept 07: Setup for Mobile
- Concept 08: Using Dev Tools on Mobile
- Concept 09: Mobile tools for iOS
- Concept 10: Lesson Summary
-
Lesson 02: Starting Small
Use the best practices in responsive design to start building from the smallest devices (mobile phones) up to the largest displays (desktop computers).
- Concept 01: Defining the Viewport
- Concept 02: Pixels, pixels and moar pixels!
- Concept 03: Setting the Viewport
- Concept 04: Setting the Viewport
- Concept 05: Large Fixed Width Elements
- Concept 06: Max-width on elements
- Concept 07: Tap Target Sizes
- Concept 08: Start Small
- Concept 09: Project Solution - Long
- Concept 10: Lesson Summary
-
Lesson 03: Building Up
Use media queries to define breakpoints in your application to easily split your site into different versions based on display size.
- Concept 01: Lesson Intro
- Concept 02: Basic Media Query Intro
- Concept 03: Adding a Basic Media Query
- Concept 04: Adding a basic media query 2
- Concept 05: Next Step Media Queries
- Concept 06: What Styles Are Applied?
- Concept 07: Breakpoints
- Concept 08: Breakpoints Pt. II
- Concept 09: Picking Breakpoints
- Concept 10: Picking Breakpoints 2
- Concept 11: Complex Media Queries
- Concept 12: Grids
- Concept 13: Flexbox Intro
- Concept 14: Flexbox Container
- Concept 15: Flex Item
- Concept 16: Deconstructing a Flexbox Layout
- Concept 17: Responsive Design Outro
-
Lesson 04: Common Responsive Patterns
Walk through the most popular responsive layout patterns and learn the tools needed to implement them in your own designs.
- Concept 01: Intro to Patterns
- Concept 02: Pattern - Column Drop
- Concept 03: Pattern - Mostly Fluid
- Concept 04: Mostly Fluid Part 1
- Concept 05: Mostly Fluid Part 2
- Concept 06: Combining Fluid Layouts
- Concept 07: Pattern - Layout Shifter
- Concept 08: Which is Which?
- Concept 09: Pattern - Off Canvas
- Concept 10: Off Canvas Visualization
- Concept 11: Project Update Part 2
- Concept 12: Lesson Summary
-
Lesson 05: Optimizations
Learn how to optimize images, tables, and fonts to make for the best responsive layouts.
- Concept 01: Lesson Intro
- Concept 02: Images
- Concept 03: Responsive Tables Intro
- Concept 04: Responsive Tables - Hidden Columns
- Concept 05: Responsive Tables - No More Tables
- Concept 06: Responsive Tables - Contained Scrolling
- Concept 07: Fonts
- Concept 08: Minor Breakpoints
- Concept 09: Final Project Updates
- Concept 10: Wrap Up
-
Lesson 06: Writing READMEs
Begin creating effective documentation for your applications by writing README files to help other developers use and read your code.
- Concept 01: Welcome
- Concept 02: What is Documentation?
- Concept 03: How Does Nija Consume Documentation?
- Concept 04: Why Should Art Have Documented His Code?
- Concept 05: Anatomy of a README
- Concept 06: Readable READMEs with Markdown
- Concept 07: Basic Markdown Syntax
- Concept 08: More Markdown Syntax
- Concept 09: Markdown Syntax Practice
- Concept 10: Document Everything!
-
-
Module 03: Project: Build a Portfolio Site
-
Lesson 01: Build a Portfolio Site
Given a PDF mockup of a website from a designer, translate it to a real website using your HTML and CSS skills.
-
Part 03 : JavaScript & The DOM
In this Part, you’ll demonstrate your mastery of HTML, CSS, and JavaScript by building a complete browser-based card matching game (also known as Concentration). From building a grid of cards, adding functionality to handle user input, and implementing gameplay logic -- you'll combine all your web development skills to create a fully interactive experience for your users.
-
Module 01: JavaScript & The DOM
-
Lesson 01: Syntax
With this major update to the JavaScript language, a number of syntax improvements have been added. In this lesson, you'll learn to improve your JavaScript code with these syntax updates.
- Concept 01: Harmony, ES6, ES2015...
- Concept 02: Let and Const
- Concept 03: Quiz: Using Let and Const (1-1)
- Concept 04: Template Literals
- Concept 05: Quiz: Build an HTML Fragment (1-2)
- Concept 06: Destructuring
- Concept 07: Quiz: Destructuring Arrays (1-3)
- Concept 08: Object Literal Shorthand
- Concept 09: Lesson 1 Checkup
- Concept 10: Iteration
- Concept 11: Family of For Loops
- Concept 12: For...of Loop
- Concept 13: Quiz: Writing a For...of Loop (1-4)
- Concept 14: Spread... Operator
- Concept 15: ...Rest Parameter
- Concept 16: Quiz: Using the Rest Parameter (1-5)
- Concept 17: Lesson 1 Summary
-
Lesson 02: The Document Object Model
The Document Object Model (DOM) allows developers to interact with and control the rendered page. You'll learn how the DOM is formed, what Nodes and Elements are, and how to select items from the DOM.
- Concept 01: Introduction
- Concept 02: The DOM
- Concept 03: Selecting Page Elements With CSS Selectors
- Concept 04: Select Page Element By ID
- Concept 05: Select Page Elements By Class Or Tag
- Concept 06: Nodes, Elements, and Interfaces...Oh My!
- Concept 07: More Ways To Access Elements
- Concept 08: Lesson summary
-
Lesson 03: Creating Content with JavaScript
Static is boring, so we'll use JavaScript and DOM methods to create new page content, update existing content, and delete content. You'll also learn how to check and set the styling of page elements.
-
Lesson 04: Working with Browser Events
Hundreds of events fire every time you interact with a page. Learn what an event is, how to listen for an event and respond to it, what data is included with an event, and the phases of an event.
-
Lesson 05: Performance
Learn how to measure the code you write to make sure it's performing efficiently and how reflow and repaint affect performance. Learn how to harness the JavaScript Event loop for performance gains.
-
-
Module 02: Project: Memory Game
-
Lesson 01: Memory Game
Build your own version of the classic memory game 'Concentration', using JavaScript, DOM selectors and Event Listeners.
-
Part 04 : Web Accessibility
Explore the diversity of different users experience with websites and applications. Learn about using screen readers practically and recognize the challenge of building web experiences for all users.
-
Module 01: Web Accessibility
-
Lesson 01: Accessibility Overview
Explore the diversity of different users experience with web sites and applications. Learn about using screen readers practically and recognize the challenge of building web experiences for all users.
- Concept 01: Introduction to Accessibility
- Concept 02: What is Accessibility
- Concept 03: Understanding the diversity of users
- Concept 04: Diversity of Users (Broken Arm)
- Concept 05: Diversity of Users (Blindness)
- Concept 06: Diversity of Users (Audio)
- Concept 07: Diversity of Users (Baby)
- Concept 08: Diversity of Users (Concussion)
- Concept 09: Diversity of Users (RSI)
- Concept 10: Using a Screen Reader
- Concept 11: Experiencing a screen reader
- Concept 12: Checklists
- Concept 13: Using WebAIM Checklist
- Concept 14: Gear Shift into Course Practicalities
-
Lesson 02: Focus
Manage focus - the location on a page that receives input from the keyboard. Discover how some users navigate website entirely with the keyboard, and how to optimize their experience.
- Concept 01: Introduction to Focus
- Concept 02: What is Focus?
- Concept 03: Experiencing Focus
- Concept 04: DOM Order Matters
- Concept 05: Fixing DOM Order
- Concept 06: Using Tabindex
- Concept 07: Deciding whats in focus
- Concept 08: Which Elements Should Have Focus?
- Concept 09: Managing Focus
- Concept 10: Manage Focus Yourself
- Concept 11: Skip Links
- Concept 12: Focus in Complex Components
- Concept 13: Keyboard Design Patterns
- Concept 14: Implementing Keyboard Event Listeners
- Concept 15: Offscreen Content
- Concept 16: Implementing Offscreen Content
- Concept 17: Modals and Keyboard Traps
- Concept 18: Lesson 2 Outro
-
Lesson 03: Semantics Basics
Dive into the differences between visual UI and semantically designed accessible UI. Add semantic elements to HTML to create a user interface that works for everyone.
- Concept 01: Semantics Introduction
- Concept 02: Assistive Technology
- Concept 03: Affordances
- Concept 04: Experiencing Affordances
- Concept 05: Semantics and Assistive Technology
- Concept 06: Experience Using a Screenreader
- Concept 07: Role, Name, Value
- Concept 08: Experience a Screen Reader 2
- Concept 09: The Accessibility Tree
- Concept 10: Matching simple DOM and A11y Tree
- Concept 11: Semantics in Native HTML
- Concept 12: Writing Semantic HTML Quiz
- Concept 13: Writing Semantic HTML: The Name Game
- Concept 14: Labeling Input Elements
- Concept 15: Text Alternatives
- Concept 16: Labeling Images With ALT Text
- Concept 17: Lesson 3 Outro
-
Lesson 04: Navigating Content
Implement effective semantic navigation using headings, link text and landmarks.
- Concept 01: Semantics - Navigating content - Intro
- Concept 02: Navigating with a screen reader
- Concept 03: Navigating by Headings
- Concept 04: Using Headings
- Concept 05: Using Headings
- Concept 06: Other navigational options
- Concept 07: Other navigational options example
- Concept 08: Link Text
- Concept 09: Link Text
- Concept 10: Landmarks
- Concept 11: Landmarks
- Concept 12: Outro Lesson 4
-
Lesson 05: ARIA
Sometimes an HTML element may not have a role or value assigned semantically. In this lesson, you'll use ARIA attributes to provide context for screen readers.
- Concept 01: Intro to Semantics: ARIA
- Concept 02: Why ARIA
- Concept 03: First Steps with ARIA
- Concept 04: What can ARIA do for you?
- Concept 05: Roleplaying
- Concept 06: Custom radio button group with ARIA
- Concept 07: More Ways to Label
- Concept 08: Name That Element!
- Concept 09: Breather
- Concept 10: Default Semantics and Landmarks
- Concept 11: ARIA Relationships
- Concept 12: Combo Box
- Concept 13: Hidden In Plain Sight
- Concept 14: Name That Element Round 2
- Concept 15: Recap so far
- Concept 16: Introducing ARIA Live
- Concept 17: Atomic Relevant Busy
- Concept 18: Recap
- Concept 19: Modal Dialog Quiz
- Concept 20: Outro Lesson 5
-
Lesson 06: Style
Incorporate CSS styling into your accessible web design and use accessible color schemes to improve accessibility.
- Concept 01: Introduction to Style
- Concept 02: Working with focus styles
- Concept 03: Write your own focus styles
- Concept 04: Input Modality
- Concept 05: Styling with ARIA, I
- Concept 06: Styling with ARIA, II
- Concept 07: Responsive design for multi-device
- Concept 08: Responsive design for multi-device Pt. 2
- Concept 09: Mobile Screen Readers
- Concept 10: Mobile Screen Readers iOS
- Concept 11: Mobile Screen Readers Android
- Concept 12: Using Mobile Screen Readers
- Concept 13: Segue to Color & Contrast
- Concept 14: Meeting Contrast Requirements
- Concept 15: Don’t convey info with color alone
- Concept 16: Contrast Audit
- Concept 17: High Contrast Mode
- Concept 18: Outro
- Concept 19: Course Outro
-
Part 05 : Object-Oriented Javascript
Objects in JavaScript encapsulate both data and functionality. You'll create, access, and modify objects to build a solid foundation for object-oriented programming. For the project, you’ll recreate the classic arcade game Frogger. You will be provided visual assets and a game loop engine; using these tools you must add a number of entities to the game including the player characters and enemies.
-
Module 01: OOJS
-
Lesson 01: Objects in Depth
Objects in JavaScript encapsulate both data and functionality. You'll create, access, and modify objects to build a solid foundation for object-oriented programming.
-
Lesson 02: Functions at Runtime
Functions are one of most important data structures. Learn what a "first-class function" is, learn about scope, dig into closures, and use immediately-invoked function expressions for private state.
-
Lesson 03: Classes and Objects
Creating objects individually isn't sustainable. Learn how to create similar objects with ease using Classes. You'll also learn how object inheritance works through Prototypal Inheritance.
-
Lesson 04: Object-Oriented Design Patterns
Discover object-oriented design patterns that can be used to create an object -- all without involving its prototype. What's more: you'll also learn how to implement private properties in objects.
-
-
Module 02: ES6 Continued
-
Lesson 01: Functions
Functions are at the heart of JavaScript! With ES6, functions are getting some much-needed improvements. In this lesson, you'll learn a number of new things including arrow functions and classes.
- Concept 01: Updates to Functions
- Concept 02: Arrow Functions
- Concept 03: Using Arrow Functions
- Concept 04: Quiz: Convert Function into an Arrow Function (2-1)
- Concept 05: Arrow Functions Recap
- Concept 06: Arrow Functions and the "this" Keyword
- Concept 07: "this" and Regular Functions
- Concept 08: "this" and Arrow Functions
- Concept 09: Default Function Parameters
- Concept 10: Defaults and Destructuring
- Concept 11: Quiz: Using Default Function Parameters (2-2)
- Concept 12: Class Preview
- Concept 13: JavaScript's Illusion of Classes
- Concept 14: JavaScript Classes
- Concept 15: Convert a Function to a Class
- Concept 16: Working with JavaScript Classes
- Concept 17: Super and Extends
- Concept 18: Extending Classes from ES5 to ES6
- Concept 19: Working with JavaScript Subclasses
- Concept 20: Quiz: Building Classes and Subclasses (2-3)
- Concept 21: Lesson 2 Summary
-
Lesson 02: Built-ins
The JavaScript environment provides you with a number of features by default. In this lesson, we'll take a look at Sets, Maps, Proxies, Generators, how iteration works, and more!
- Concept 01: New Built-ins
- Concept 02: Symbols Intro
- Concept 03: Symbols
- Concept 04: Iteration & Iterable Protocols
- Concept 05: Sets
- Concept 06: Modifying Sets
- Concept 07: Working with Sets
- Concept 08: Sets & Iterators
- Concept 09: Quiz: Using Sets
- Concept 10: WeakSets
- Concept 11: Quiz: Working With WeakSets
- Concept 12: Maps
- Concept 13: Creating & Modifying Maps
- Concept 14: Working with Maps
- Concept 15: Looping Through Maps
- Concept 16: WeakMaps
- Concept 17: Promises Intro
- Concept 18: Promises
- Concept 19: More Promises
- Concept 20: Proxies Intro
- Concept 21: Proxies
- Concept 22: Proxies vs. ES5 Getter/Setter
- Concept 23: Proxies Recap
- Concept 24: Generators
- Concept 25: Generators & Iterators
- Concept 26: Sending Data into/out of a Generator
- Concept 27: Lesson 3 Summary
-
Lesson 03: Professional Developer-fu
With this massive improvement, not all browsers are able to support this new version of JavaScript. In this lesson, you'll learn about using polyfills and transpiling your ES6 JavaScript code to ES5.
- Concept 01: The Web is Growing Up
- Concept 02: Old and New Browsers
- Concept 03: ES6 Specification
- Concept 04: Supported Features
- Concept 05: The Web is Eternal
- Concept 06: Polyfills
- Concept 07: Using Polyfills
- Concept 08: Polyfill Walkthrough
- Concept 09: Other Uses for Polyfills
- Concept 10: Transpiling
- Concept 11: Using Babel
- Concept 12: Transpiling Walkthrough
- Concept 13: Transpiling Recap
- Concept 14: Course Summary
-
-
Module 03: Project: Classic Arcade Game Clone
-
Lesson 01: Classic Arcade Game Clone
You will be provided with visual assets and a game loop engine; using these tools you must add a number of entities to the game including the player characters and enemies to recreate a classic game!
-
Part 06 : JavaScript Tools & Testing
Testing is an important part of the development process and many organizations practice a standard known as "test-driven development" or TDD. This is when developers write tests first, before they ever start developing their application. Whether you work in an organization that writes tests extensively to inform product development or one that uses tests to encourage iteration, testing has become an essential skill in modern web development!
-
Module 01: Web Tooling and Automation
-
Lesson 01: Introducing Web Tooling and Automation
Learn how automation and tooling can make you more productive as a developer and allow you to work more faster and more efficiently.
-
Lesson 02: Productive Editing
Use keyboard shortcuts and code editor extensions to speed up your development process and help to avoid repetitive typing tasks.
-
Lesson 03: Powerful Builds
Leverage the power of build tools like Gulp and Grunt to automate the process of converting your development code into streamlined production-ready code.
- Concept 01: Lesson Intro
- Concept 02: Overview of Build Tools
- Concept 03: Getting Started with Gulp
- Concept 04: Install Gulp
- Concept 05: Hello Gulp
- Concept 06: Grunt Tasks vs Gulp Streams
- Concept 07: Making CSS Suck Less
- Concept 08: Using Gulp w/ Sass
- Concept 09: Using Gulp w/ Autoprefixer
- Concept 10: Using Gulp
- Concept 11: Lesson Outro
-
Lesson 04: Expressive Live Editing
Learn how to set up your environment for live editing. Live editing will cause any connected browser to automatically reload if you change any file it's watching in your project.
-
Lesson 05: How to Prevent Disasters
Learn how to use tooling to be a safety net for you as you're coding. Use it to automatically check the code you write and automatically run tests.
- Concept 01: Lesson Intro
- Concept 02: Why Rely on Tools to Prevent Bad Things
- Concept 03: Linting
- Concept 04: Setting Up ESLint
- Concept 05: Setting up ESLint in Gulp
- Concept 06: Unit Testing in Gulp
- Concept 07: Unit Testing in Gulp
- Concept 08: What's Next?
- Concept 09: Continuous Integration
- Concept 10: Lesson Outro
-
Lesson 06: Awesome Optimizations
Learn how to use tooling to optimize your apps for production use. You'll learn how to concatenate, minify, and optimize your code.
- Concept 01: Lesson Intro
- Concept 02: Development and Production Modes
- Concept 03: Development and Production Modes Part 2
- Concept 04: CSS Concatenation
- Concept 05: JS Concatenation
- Concept 06: JS Concatenation Hands On
- Concept 07: Minification
- Concept 08: Setting up a production task
- Concept 09: Writing Future Proof JavaScript
- Concept 10: Source Maps
- Concept 11: Image Optimization
- Concept 12: We Love Optimization
- Concept 13: Image Compression
- Concept 14: Lesson Outro
-
Lesson 07: Web Tooling and Automation Conclusion
You're on your way to tooling greatness. In this lesson, you'll learn about tooling to scaffold entire projects.
-
-
Module 02: JavaScript Testing
-
Lesson 01: Rethinking Testing
Learn why writing tests is an important part of any project and get started writing your own tests.
-
Lesson 02: Writing Test Suites
Learn how to use the Jasmine test suite to run tests against your code and handle varying situations including asynchronous code.
- Concept 01: Introduction to Jasmine
- Concept 02: Exploring the SpecRunner
- Concept 03: Introducing Suites and Specs
- Concept 04: Writing a Test
- Concept 05: Getting Started with Red-Green-Refactor
- Concept 06: Writing AddressBookSpec.js
- Concept 07: Iterating on our Implementation
- Concept 08: Mike's Solution
- Concept 09: Another Spec
- Concept 10: Removing Redundant Code
- Concept 11: Testing Asynchronous Code
- Concept 12: Writing an Asynchronous Test
- Concept 13: Correcting our Asynchronous Test
- Concept 14: Course Conclusion
-
-
Module 03: Project: Feed Reader Testing
-
Lesson 01: Feed Reader Testing
You have been given a feed reader application that another developer has worked on, and now need to write tests against it using Jasmine's testing syntax.
-
-
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
-
Part 07 : Front-End Applications
You will convert a static webpage to a mobile-ready web application. You will take a static design that lacks accessibility and convert the design to be responsive on different sized displays and accessible for screen reader use. You will also begin converting this to a Progressive Web Application by caching some assets for offline use.
-
Module 01: Front-End Applications
-
Lesson 01: Changing Expectations
Learn why well-structured code is vitally important to a web app's structure, especially as the app gets larger. Explore how you can use MV* organizational framework to create cleaner projects.
- Concept 01: Welcome
- Concept 02: Introduce Cat Clicker and Andy
- Concept 03: Cat Clicker Requirements
- Concept 04: Reflections
- Concept 05: Andy's Reflections
- Concept 06: Requirements Change All The Time
- Concept 07: First Requirements Change
- Concept 08: Cat Clicker Requirements 2
- Concept 09: Reflections 2
- Concept 10: Andy's Reflections 2
- Concept 11: Closures and Event Listeners
- Concept 12: Second Requirements Change
- Concept 13: Cat Clicker Premium Requirements
- Concept 14: Reflections 3
- Concept 15: Andy's Reflections 3
- Concept 16: Spaghetti Code Story Time
- Concept 17: What is Spaghetti Code
- Concept 18: Introduction to MVO
- Concept 19: Explore The App's Structure
- Concept 20: Model Quiz
- Concept 21: View Quiz
- Concept 22: What Is the Model in Our Code
- Concept 23: What Is the View in Our Code
- Concept 24: What Is the Octopus in Our Code
- Concept 25: Identify the MVO in New App
- Concept 26: Where Should This Feature Live?
- Concept 27: Implement Note Date
- Concept 28: Segue Into L2
-
Lesson 02: Refactoring with Separation of Concerns
Begin refactoring your Cat Clicker code and learn the best ways to improve its structure.
- Concept 01: Introduction to Lesson 2
- Concept 02: Identify Model and View
- Concept 03: Review Model and View for CC Premium
- Concept 04: Identify Octopus
- Concept 05: Andy’s Code 1
- Concept 06: Andy's Code 2
- Concept 07: In Defense of Andy
- Concept 08: Rebuild Cat Clicker Premium
- Concept 09: Cat Clicker Premium Specs
- Concept 10: Cat Clicker Premium Solution
- Concept 11: Cat Clicker Premium Solution Review
- Concept 12: Cat Clicker Premium Pro
- Concept 13: Cat Clicker Premium Pro Specs
- Concept 14: How to Modernize Projects
- Concept 15: Interview with Nic
- Concept 16: Interview with Jacques
- Concept 17: Refactor Spaghetti Code
- Concept 18: Repository for Attendance App
- Concept 19: What Method Did You Use?
- Concept 20: Interview With The Author
- Concept 21: Refactoring the Resumé
- Concept 22: Repository Information for Resume
- Concept 23: Segue Into L3
-
Lesson 03: Creating Promises
Learn what a promise is, how it makes writing asynchronous JavaScript simpler and how to handle errors.
- Concept 01: Course Introduction
- Concept 02: Callbacks vs Promises
- Concept 03: Callbacks vs Thens
- Concept 04: Course Map
- Concept 05: Promise Timeline
- Concept 06: Async Scenarios
- Concept 07: Syntax
- Concept 08: Write Your First Promise
- Concept 09: Wrapping readyState
- Concept 10: IMPORTANT! Working w/Exoplanet Explorer
- Concept 11: Wrap an XHR
- Concept 12: Web Technologies
- Concept 13: Fetch API
- Concept 14: What Happens Next?
-
Lesson 04: Chaining Promises
Create sequences of asynchronous work by chaining Promises together and dive into more advanced error handling.
- Concept 01: Fetch and Show First Planet
- Concept 02: Error Handling Strategies
- Concept 03: Chaining Thenables
- Concept 04: Series vs Parallel Requests
- Concept 05: Array Methods and Promises
- Concept 06: Promises with .forEach
- Concept 07: Promises with .map
- Concept 08: All Promises
- Concept 09: Course Outro
- Concept 10: Exoplanets 101
- Concept 11: Bonus Question: Parallel Requests
-
Lesson 05: Ajax with XHR
In this lesson, you'll learn why you should use asynchronous data requests. Use the
XHRobject to send and receive data asynchronously.- Concept 01: Course Intro
- Concept 02: Client Server Demonstration
- Concept 03: Ajax Definition & Examples
- Concept 04: APIs
- Concept 05: Create An Async Request with XHR
- Concept 06: The XHR Object
- Concept 07: XHR's .open() method
- Concept 08: XHR's .send() method
- Concept 09: A Full Request
- Concept 10: Project Initial Walkthrough
- Concept 11: Setting a Request Header
- Concept 12: Project Final Walkthrough
- Concept 13: XHR Recap
- Concept 14: XHR Outro
-
Lesson 06: Ajax with jQuery
In this lesson, you'll compare using
XHRwith using jQuery's Ajax method. You'll send and receive data using jQuery's Ajax methods and learn how jQuery's Ajax works under the hood.- Concept 01: The jQuery Library & Ajax
- Concept 02: jQuery's `ajax()` Method
- Concept 03: Handling The Returned Data
- Concept 04: Cleaning up the Success Callback
- Concept 05: Code Walkthrough
- Concept 06: Peek inside $.ajax()
- Concept 07: Review the Call Stack
- Concept 08: Walkthrough of .ajaxTransport
- Concept 09: jQuery's Other Async Methods
- Concept 10: Async with jQuery Outro
-
Lesson 07: Ajax with Fetch
In this lesson, you'll use JavaScript Promises to create a fetch request and handle the returned data asynchronously. You'll also learn how to handle errors for failed requests.
- Concept 01: Ajax call with the Fetch API
- Concept 02: What is Fetch
- Concept 03: Write the Fetch Request
- Concept 04: Handle The Response
- Concept 05: The Response Object
- Concept 06: ES6 Arrow Function
- Concept 07: Display Content & Handling Errors
- Concept 08: Project Wrap-up
- Concept 09: Fetch Outro
- Concept 10: Course Outro
-
Lesson 08: Features of Single Page Apps
Learn about the features of a single page web application.
- Concept 01: Welcome
- Concept 02: How To Be Successful
- Concept 03: Explore a Front End Application
- Concept 04: Server-based and AJAX Powered Sites
- Concept 05: Server and Client Apps
- Concept 06: Single Page Apps
- Concept 07: Frameworks
- Concept 08: Core Framework Components
- Concept 09: Code and File Organization
- Concept 10: Templates, URLs, and Events
- Concept 11: Storage - the absent component?
- Concept 12: Features of Specialized Frameworks
- Concept 13: Interview with Dhruv
- Concept 14: Outro
-
Lesson 09: Examine a Framework's Source
Dig around in the Backbone framework to discover how many of its most popular features work.
- Concept 01: A Framework's Base Features
- Concept 02: What is a template?
- Concept 03: Backbone Project Setup
- Concept 04: Underscore Templates
- Concept 05: Constructor Function
- Concept 06: Constructor Function Quiz
- Concept 07: Walk-thru the `template` function
- Concept 08: Filling the template with data
- Concept 09: Interview with Scott
- Concept 10: Template `variables` and JS's `with`
- Concept 11: Template Bug Quiz
- Concept 12: Build Your Own Templating Function Quiz
- Concept 13: addEventListener
- Concept 14: Setting up Backbone Events
- Concept 15: Walk-thru Backbone's `Events.on`
- Concept 16: Adding Events Quiz
- Concept 17: Walk-thru Backbone's `Events.trigger`
- Concept 18: Events Quiz
- Concept 19: Build Your Own Event System Quiz
- Concept 20: A Router & The Backbone.history Object
- Concept 21: Routing Quiz
- Concept 22: hashchange & pushState
- Concept 23: Stepping thru Backbone.history.start()
- Concept 24: Backbone's Fragment Count Quiz
- Concept 25: Lesson Highlight Summary Quiz
- Concept 26: Outro
-
Lesson 10: Angular
Learn how to build a single page application in the Angular framework.
- Concept 01: Welcome to Angular
- Concept 02: Angular what?
- Concept 03: Quiz Repos & Feedback Chrome Extension
- Concept 04: Up and Running with Angular Quiz
- Concept 05: The Angular Ecosystem
- Concept 06: New Feature 1 Quiz
- Concept 07: New Feature 2 Quiz
- Concept 08: A Simple App
- Concept 09: Installing Yeoman
- Concept 10: A Structured App
- Concept 11: An Angular Module
- Concept 12: Create a Module Quiz
- Concept 13: Bootstrap the App
- Concept 14: Bootstrap an App Quiz
- Concept 15: Templates and Expressions
- Concept 16: Expression Quiz
- Concept 17: Interview with Scott
- Concept 18: Angular Controllers
- Concept 19: Angular Controllers Quiz
- Concept 20: Scope
- Concept 21: Scope/$scope in Controllers
- Concept 22: Scope Quiz
- Concept 23: Take a Breather
- Concept 24: The long awaited Directives
- Concept 25: Directives Quiz
- Concept 26: Dependency Injection Skit
- Concept 27: Services
- Concept 28: Services Quiz
- Concept 29: Order Manager Feature
- Concept 30: A couple of ways to inject in Angular
- Concept 31: Routing via UI-Router
- Concept 32: Managing Application State
- Concept 33: Nested Views
- Concept 34: Routing Quiz
- Concept 35: Outro
-
Lesson 11: Ember
Learn how to build a single page application in the Ember framework.
- Concept 01: Welcome to Ember
- Concept 02: Required ES6 Knowledge
- Concept 03: Installing Ember-CLI
- Concept 04: Using Ember-CLI To Generate A New App
- Concept 05: An Ember App's File Structure
- Concept 06: Routes, Routers, and Templates - Oh My!
- Concept 07: Generating a Route & Template
- Concept 08: Quiz Repos & Feedback Chrome Extension
- Concept 09: Viewing A Menu Item
- Concept 10: Nested Routes
- Concept 11: Interview with Allen
- Concept 12: Handlebars
- Concept 13: Loading Dynamic Data
- Concept 14: Updating the Item Template
- Concept 15: Components Ember-style Custom HTML
- Concept 16: Order Tracking Feature
- Concept 17: Consuming a Service
- Concept 18: Responding To User Actions
- Concept 19: Outro
-
Lesson 12: The Benefits of Offline First
Discover the differences between a standard web app and an offline-first application and get an introduction to new APIs.
- Concept 01: Intro
- Concept 02: The Problem
- Concept 03: The Benefits of Offline First
- Concept 04: What Can Slow Us Down
- Concept 05: What Does Online First Look Like
- Concept 06: What Are Ways To Be Offline First
- Concept 07: Introducing the Demo App
- Concept 08: Installing the Demo App
- Concept 09: Running the Demo App
- Concept 10: Exploring the Demo Apps Code
- Concept 11: Changing Connection Types
- Concept 12: Testing Lie Fi Mode
- Concept 13: Introducing Service Worker
-
Lesson 13: Introducing the Service Worker
Write your first Service Workers and get comfortable with the lifecycle of a request when using a service worker
- Concept 01: An Overview of Service Worker
- Concept 02: Scoping Quiz
- Concept 03: Adding a Service Worker To the Project
- Concept 04: Registering a Service Worker
- Concept 05: The Service Worker Lifecycle
- Concept 06: Enabling Service Worker Dev Tools
- Concept 07: Service Worker Dev Tools
- Concept 08: Service Worker Dev Tools 2
- Concept 09: Service Worker Dev Tools Continued
- Concept 10: Hijacking Requests
- Concept 11: Hijacking Requests 1 Quiz
- Concept 12: Hijacking Requests 2
- Concept 13: Hijacking Requests 2 Quiz
- Concept 14: Hijacking Requests 3
- Concept 15: Hijacking Requests 3 Quiz
- Concept 16: Caching and Serving Assets
- Concept 17: Install and Cache Quiz
- Concept 18: Cache Response Quiz
- Concept 19: Updating the Static Cache
- Concept 20: Update Your CSS Quiz
- Concept 21: Update Your CSS 2
- Concept 22: Adding UX to the Update Process
- Concept 23: Adding UX Quiz
- Concept 24: Triggering an Update
- Concept 25: Triggering an Update Quiz
- Concept 26: Caching the Page Skeleton
-
-
Module 02: Project: Restaurant Reviews App
-
Lesson 01: Restaurant Reviews App
In this real-world case study, given the front-end code for a static Restaurant Reviews App, revise the site to be responsive and achieve accessibility standards.
-
Part 08 : Congratulations! What's Next?
Great work finishing the program! Here's some advice on next steps in your programming journey.
-
Module 01: Congratulations
-
Lesson 01: Congratulations! What's Next?
Congratulations! You've completed the Front-End Nanodegree program! Check out this overview of all the great things you've learned and some of the next steps available to you.
-
Part 09 (Elective): High Conversion Web Forms
Get started using the proper input types to make forms as simple to complete as possible for your users.
-
Module 01: Elective Material
-
Lesson 01: Efficient Inputs Part 1
Get started using the proper input types to make forms as simple to complete as possible for your users.
- Concept 01: Course Intro
- Concept 02: Fix This Form
- Concept 03: Luke Interview Part 1
- Concept 04: Why Care about Forms
- Concept 05: The Principles of Useful Forms
- Concept 06: Form Fixing Strategies
- Concept 07: Death to Dropdowns!
- Concept 08: HTML5 Inputs
- Concept 09: Pick an Input
- Concept 10: Datalist Quiz
- Concept 11: LukeW Interview Part 2
- Concept 12: Lesson Outro
-
Lesson 02: Efficient Inputs Part 2
Start adding other features to your inputs, such as autofill and validation.
- Concept 01: Lesson 2 Intro
- Concept 02: Pop Quiz HS
- Concept 03: The Label Element
- Concept 04: Make A Label
- Concept 05: Interview with Luke W. Part 3
- Concept 06: Label Sizing and Positions
- Concept 07: Placeholders
- Concept 08: Placeholder
- Concept 09: Calendars
- Concept 10: Calendars
- Concept 11: Typos
- Concept 12: Autocomplete
- Concept 13: Autocomplete
- Concept 14: Autofocus
- Concept 15: Use Past Data to Fill Inputs
- Concept 16: Validation
- Concept 17: Numeric Validation
- Concept 18: Validate Some Inputs
- Concept 19: Constraints Validation API
- Concept 20: Validate Some Data
- Concept 21: Interview with Luke W part 4
- Concept 22: Lesson 2 Outro
-
Lesson 03: Fast Forms
Begin optimizing entire forms, rather than individual elements, to create high conversion web forms.
- Concept 01: Lesson 3 Intro
- Concept 02: Form Principles
- Concept 03: Duck It’s Storming Brains
- Concept 04: LukeW Interview part 5
- Concept 05: I Just Need to Check My Payment Info
- Concept 06: But I'm Not Ready to Commit
- Concept 07: Draw a Conclusion
- Concept 08: Finish on Another Device
- Concept 09: Fast Forms = More Conversions
- Concept 10: Interview with Luke W part 6
- Concept 11: One Weird Trick
- Concept 12: Location
- Concept 13: Build a Checkout
- Concept 14: Interview with Luke W part 7
- Concept 15: Lesson 3 Outro
-
Lesson 04: Touch Support
Learn about the special considerations required when building excellent forms on mobile devices, such as touch events.
- Concept 01: Lesson 4 Intro
- Concept 02: It Can't be That Bad, Right?
- Concept 03: Touch Pseudo States
- Concept 04: Too Much Touch
- Concept 05: Build a Better UI
- Concept 06: Interview with Luke W part 8
- Concept 07: Quick Practice with Event Listeners
- Concept 08: Touch Events
- Concept 09: Interact with a Single Element
- Concept 10: Final Project Instructions and Rubric
- Concept 11: Course Outro
-
Part 10 (Elective): Client Server Communication
Learn the ins and outs of requests. Understand how a page is requested, the headers that are received, HTTP codes, and how data is transferred.
-
Module 01: Elective Material
-
Lesson 01: HTTP's Request/Response Cycle
You'll learn the ins and outs of requests. You'll look at how a page is requested, the headers that are received, HTTP codes, and how data is transferred.
- Concept 01: Intro
- Concept 02: HTTP Requests
- Concept 03: HTTP Requests 2
- Concept 04: Fetching a single request
- Concept 05: Fetching a single request 2
- Concept 06: Getting Multiple Requests
- Concept 07: Exercise Setup
- Concept 08: DevTools Quiz
- Concept 09: Sending data with a POST Request
- Concept 10: From XHR to Fetch
- Concept 11: Fetch Quiz
- Concept 12: Outro
-
Lesson 02: HTTP/1
You'll take a deep dive into HTTP verbs. You'll dig in deep to the vital headers used in HTTP. You'll also learn how to efficiently structure applications using REST.
- Concept 01: HTTP Intro
- Concept 02: The Netcat Command
- Concept 03: HTTP Verbs
- Concept 04: HTTP Verbs 2
- Concept 05: HTTP Verbs Quiz
- Concept 06: Common Response Headers
- Concept 07: Request Headers Quiz
- Concept 08: REST
- Concept 09: REST Quiz
- Concept 10: Performance Basics
- Concept 11: Performance Details
- Concept 12: Performance Details 2
- Concept 13: Outro
-
Lesson 03: HTTPS
You'll discover just how important security is to the web. You'll learn about TLS, discover issues with loading mixed content, have a quick primer on cryptography and verify Certificate Authorities.
- Concept 01: HTTPS Intro
- Concept 02: Securing HTTP
- Concept 03: MITM Quiz 1
- Concept 04: MITM Quiz 2
- Concept 05: TLS and Certificate Authorities
- Concept 06: TLS: Cryptography Primer
- Concept 07: TLS: Hashing
- Concept 08: Hashing Quiz
- Concept 09: Certificate Authority Signatures
- Concept 10: The TLS Handshake
- Concept 11: SSL Error Quiz
- Concept 12: Mixed Content
- Concept 13: Mixed Content Quiz
- Concept 14: Outro
-
Lesson 04: HTTP/2
HTTP/1 is great, but the future is HTTP/2! You'll learn about the changes that HTTP/2 brings. You'll learn the current "best practices" that HTTP/1 extols, but that are now anti-patterns in HTTP/2.
- Concept 01: HTTP/2 Intro
- Concept 02: HTTP/1 Problem: Head of Line Blocking
- Concept 03: HTTP/1 Problem: Uncompressed Headers
- Concept 04: HTTP/1 Problem: Security
- Concept 05: HTTP/2 Improvements
- Concept 06: HTTP/1 vs HTTP/2 Quiz
- Concept 07: Working with HTTP/2
- Concept 08: Development Techniques for HTTP/2 Quiz
- Concept 09: Outro
-
Lesson 05: Security
Security is vital for every web application! You'll learn about common security pitfalls and how to avoid them. You'll also get a chance to don your white hat and hack into a (sample) bank's website.
- Concept 01: Security Intro
- Concept 02: Origins
- Concept 03: Origins 2
- Concept 04: Overriding Same Origin Policy
- Concept 05: CORS
- Concept 06: Preflight Request with CORS Quiz 1
- Concept 07: Preflight Request with CORS Quiz 2
- Concept 08: Preflight Request with CORS Quiz 3
- Concept 09: Security Exploit - CSRF
- Concept 10: CSRF Quiz
- Concept 11: Security Exploit - XSS
- Concept 12: XSS Quiz
- Concept 13: Security Outro
- Concept 14: Course Outro
-
Part 11 (Elective): Shell Workshop
The Unix shell is a powerful tool for developers of all sorts. You'll get a quick introduction to the very basics of using it on your own computer.
-
Module 01: Elective Material
-
Lesson 01: Shell Workshop
The Unix shell is a powerful tool for developers of all sorts. In this lesson, you'll get a quick introduction to the very basics of using it on your own computer.
- Concept 01: The Command Line
- Concept 02: Intro to the Shell
- Concept 03: Windows: Installing Git Bash
- Concept 04: Opening a terminal
- Concept 05: Your first command (echo)
- Concept 06: Navigating directories (ls, cd, ..)
- Concept 07: Current working directory (pwd)
- Concept 08: Parameters and options (ls -l)
- Concept 09: Organizing your files (mkdir, mv)
- Concept 10: Downloading (curl)
- Concept 11: Viewing files (cat, less)
- Concept 12: Removing things (rm, rmdir)
- Concept 13: Searching and pipes (grep, wc)
- Concept 14: Shell and environment variables
- Concept 15: Startup files (.bash_profile)
- Concept 16: Controlling the shell prompt ($PS1)
- Concept 17: Aliases
- Concept 18: Keep learning!
-
Part 12 (Elective): Version Control with Git & GitHub
You'll learn about the benefits of version control and install the version control tool Git!
-
Module 01: Elective Material
-
Lesson 01: What is Version Control?
Version control is an incredibly important part of a professional programmer's life. In this lesson, you'll learn about the benefits of version control and install the version control tool Git!
-
Lesson 02: Create A Git Repo
Now that you've learned the benefits of Version Control and gotten Git installed, it's time you learn how to create a repository.
-
Lesson 03: Review a Repo's History
Knowing how to review an existing Git repository's history of commits is extremely important. You'll learn how to do just that in this lesson.
-
Lesson 04: Add Commits To A Repo
A repository is nothing without commits. In this lesson, you'll learn how to make commits, write descriptive commit messages, and verify the changes you're about to save to the repository.
-
Lesson 05: Tagging, Branching, and Merging
Being able to work on your project in isolation from other changes will multiply your productivity. You'll learn how to do this isolated development with Git's branches.
-
Lesson 06: Undoing Changes
Help! Disaster has struck! You don't have to worry, though, because your project is tracked in version control! You'll learn how to undo and modify changes that have been saved to the repository.
-
Lesson 07: Working With Remotes
You'll learn how to create remote repositories on GitHub and how to get and send changes to the remote repository.
-
Lesson 08: Working On Another Developer's Repository
In this lesson, you'll learn how to fork another developer's project. Collaborating with other developers can be a tricky process, so you'll learn how to contribute to a public project.
-
Lesson 09: Staying In Sync With A Remote Repository
You'll learn how to send suggested changes to another developer by using pull requests. You'll also learn how to use the powerful
git rebasecommand to squash commits together.
-
Part 13 (Elective): Intro to jQuery
Enter the exciting, interactive world of the DOM! Learn how to use JavaScript and jQuery to select and manipulate HTML elements on a page.
-
Module 01: Elective Material
-
Lesson 01: The Basics: the DOM, $, and Selectors
Enter the exciting, interactive world of the DOM! Learn how to use JavaScript and jQuery to select and manipulate HTML elements on a page.
- Concept 01: Course Introduction
- Concept 02: Why Does jQuery Exist?
- Concept 03: What is jQuery actually
- Concept 04: Money, Money, Money (the $)
- Concept 05: How to Use the $
- Concept 06: DOM Inspiration
- Concept 07: How Is jQuery Included in a Page?
- Concept 08: Select by Tags
- Concept 09: Select by Classes Quiz
- Concept 10: Select by IDs
- Concept 11: Family Tree Revisited
- Concept 12: Filters Quiz
- Concept 13: High Five!
-
Lesson 02: The Tricks: DOM Manipulation
Now that you've seen how to select elements using jQuery, learn to manipulate the DOM and change a webpage dynamically.
- Concept 01: jQuery Documentation and You
- Concept 02: you.toggleClass() Quiz
- Concept 03: Toggling Classes Quiz
- Concept 04: Changing Attributes Quiz
- Concept 05: Modifying CSS Quiz
- Concept 06: Pulling HTML and Text
- Concept 07: Collecting Values Quiz
- Concept 08: Removing DOM Elements
- Concept 09: Adding DOM Elements
- Concept 10: Appending Child Elements
- Concept 11: Build a DOM (Family) Tree!
- Concept 12: Iterating with Each Quiz
- Concept 13: Why use jQuery? Quiz
- Concept 14: Outro
- Concept 15: $(function)
-
Lesson 03: Event Listeners with jQuery
Learn how to use jQuery to listen for events (like a mouse click or the pressing of a key on the keyboard) and respond to these events.
- Concept 01: Intro to Event Listening with jQuery
- Concept 02: What are Browser Events?
- Concept 03: monitorEvents Quiz
- Concept 04: Anatomy of a jQuery Event Listener
- Concept 05: jQuery Event Listener Order Quiz
- Concept 06: jQuery Event Listener
- Concept 07: The Event Object
- Concept 08: The Convenience Method
- Concept 09: Convenience Methods Quiz
- Concept 10: jQuery's multifunctional .on method
- Concept 11: Event Delegation
- Concept 12: Outro
-