CF

JavaScript: Understanding the Weird Parts

12h 10m 48s
English
Paid

JavaScript: Understanding the Weird Parts is a 79-lesson 12 hours 10 minutes self-paced course by Anthony Alicea, Udemy. In this course you will gain a deep understanding of Javascript, learn how Javascript works under the hood, and how that knowledge helps you avoid common pitfalls and drastically improve your ability to debug problems .

Course facts

Lessons
79
Duration
12 hours 10 minutes
Level
All levels
Language
English
Updated
Instructor
Anthony Alicea, Udemy
Price
Premium

In this course you will gain a deep understanding of Javascript, learn how Javascript works under the hood, and how that knowledge helps you avoid common pitfalls and drastically improve your ability to debug problems. You will find clarity in the parts that others, even experienced coders, may find weird, odd, and at times incomprehensible. You'll learn the beauty and deceptive power of this language that is at the forefront of modern software development today.

Javascript is the language that modern developers need to know, and know well. Truly knowing Javascript will get you a job, and enable you to build quality web and server applications.

NOTE: This course includes information on ECMAScript 6 (ES6) the next version of Javascript!

This course will cover such advanced concepts as objects and object literals, function expressions, prototypical inheritance, functional programming, scope chains, function constructors (plus new ES6 features), immediately invoked function expressions (IIFEs), call, apply, bind, and more.

We'll take a deep dive into the source code of popular frameworks such as jQuery and Underscore to see how you can use your understanding of Javascript to learn (and borrow) from other's good code.

Finally, you'll learn the foundations of how to build your own Javascript framework or library.

What you'll learn in this course will make you a better Javascript developer, and improve your abilities in AngularJS, NodeJS, jQuery, React, Ember, MongoDB, and all other Javascript-based technologies!

Learn to love Javascript, and code in it well.

Who this course is for:
  • Those with basic Javascript skills who wish to improve
  • Experienced coders coming from other programming languages
  • New and experienced Javascript coders who want to deepen their understanding of the language
  • Anyone who has found concepts just as object prototypes, closures, and other advanced concepts difficult to learn
  • Those who have suffered surprising errors while writing Javascript, and want to learn why and how to avoid them
  • Those interested in building their own frameworks, or being better able to learn from the source code of other well-known frameworks and libraries

Who teaches JavaScript: Understanding the Weird Parts?

Anthony Alicea

Anthony Alicea thumbnail

Anthony Alicea is a US software engineer and educator best known for JavaScript: Understanding the Weird Parts — one of the canonical paid courses on JavaScript's underlying mental model (execution context, scope chain, prototype inheritance, the call stack) and one of the most widely-recommended deep-dives into the language for developers ready to move past surface syntax.

The course catalog extends into TypeScript (the deep type-system material rather than the syntax tour), React, Node.js, and the broader JavaScript ecosystem. The teaching style is unusually rigorous about the language fundamentals — Anthony's courses are taught at the level of someone who wants you to understand why JavaScript behaves the way it does, not just memorise the rules.

The CourseFlix listing under this source carries 7 Anthony Alicea courses spanning that range. Material is paid and aimed at developers ready to deepen their craft on the JavaScript / TypeScript stack.

Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in JavaScript: Understanding the Weird Parts?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 79 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction and The Goal of This Course
All Course Lessons (79)
#Lesson TitleDurationAccess
1
Introduction and The Goal of This Course Demo
04:57
2
Setup
03:28
3
Big Words and Javascript
01:26
4
Understanding, Frameworks, and The Weird Parts
04:18
5
Conceptual Aside: Syntax Parsers, Execution Contexts, and Lexical Environments
07:36
6
Conceptual Aside: Name/Value Pairs and Objects
04:09
7
The Global Environment and The Global Object
10:59
8
The Execution Context - Creation and Hoisting
09:44
9
Conceptual Aside: Javascript and 'undefined'
08:05
10
The Execution Context - Code Execution
02:55
11
Conceptual Aside: Single Threaded, Synchronous Execution
02:17
12
Function Invocation and the Execution Stack
08:07
13
Functions, Context, and Variable Environments
07:57
14
The Scope Chain
17:26
15
Scope, ES6, and let
04:19
16
What About Asynchronous Callbacks?
10:27
17
Conceptual Aside: Types and Javascript
02:51
18
Primitive Types
05:18
19
Conceptual Aside: Operators
06:33
20
Operator Precedence and Associativity
14:15
21
Conceptual Aside: Coercion
06:15
22
Comparison Operators
19:43
23
Existence and Booleans
07:24
24
Default Values
07:52
25
Framework Aside: Default Values
07:12
26
Objects and the Dot
15:24
27
Objects and Object Literals
10:33
28
Framework Aside: Faking Namespaces
08:08
29
JSON and Object Literals
07:18
30
Functions are Objects
08:03
31
Function Statements and Function Expressions
20:33
32
Conceptual Aside: By Value vs By Reference
16:10
33
Objects, Functions, and 'this'
21:27
34
Conceptual Aside: Arrays - Collections of Anything
05:40
35
'arguments' and spread
12:01
36
Framework Aside: Function Overloading
04:44
37
Conceptual Aside: Syntax Parsers
02:26
38
Dangerous Aside: Automatic Semicolon Insertion
05:48
39
Framework Aside: Whitespace
04:26
40
Immediately Invoked Functions Expressions (IIFEs)
17:08
41
Framework Aside: IIFEs and Safe Code
08:06
42
Understanding Closures
11:10
43
Understanding Closures - Part 2
19:21
44
Framework Aside: Function Factories
12:25
45
Closures and Callbacks
08:27
46
call(), apply(), and bind()
20:56
47
Functional Programming
20:18
48
Functional Programming - Part 2
08:06
49
Conceptual Aside: Classical vs Prototypal Inheritance
05:12
50
Understanding the Prototype
14:03
51
Everything is an Object (or a primitive)
05:47
52
Reflection and Extend
15:00
53
Function Constructors, 'new', and the History of Javascript
15:55
54
Function Constructors and '.prototype'
10:25
55
Dangerous Aside: 'new' and functions
04:17
56
Conceptual Aside: Built-In Function Constructors
10:33
57
Dangerous Aside: Built-In Function Constructors
03:58
58
Dangerous Aside: Arrays and for..in
03:17
59
Object.create and Pure Prototypal Inheritance
12:38
60
ES6 and Classes
06:28
61
Initialization
05:42
62
'typeof' , 'instanceof', and Figuring Out What Something Is
06:42
63
Strict Mode
05:52
64
Learning From Other's Good Code
03:52
65
Deep Dive into Source Code: jQuery - Part 1
21:32
66
Deep Dive into Source Code: jQuery - Part 2
15:39
67
Deep Dive into Source Code: jQuery - Part 3
11:23
68
Requirements
02:59
69
Structuring Safe Code
03:08
70
Our Object and Its Prototype
09:18
71
Properties and Chainable Methods
16:59
72
Adding jQuery Support
05:23
73
Good Commenting
02:22
74
Let's Use Our Framework
08:12
75
A Side Note
00:33
76
TypeScript, ES6, and Transpiled Languages
04:34
77
Existing and Upcoming Features
00:55
78
Promises, Async, and Await
42:44
79
Learning to Love the Weird Parts
01:15
Unlock unlimited learning

Get instant access to all 78 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to JavaScript: Understanding the Weird Parts?

More courses by Anthony Alicea

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course does not list specific prerequisites, but having a basic understanding of programming concepts and some experience with JavaScript would be beneficial. The course aims to provide a deep understanding of JavaScript, so familiarity with basic syntax and structures will help.
What kind of projects or exercises will I work on during the course?
The course includes conceptual asides and practical exercises that help students understand JavaScript's unique aspects, such as closures, scope, and execution context. While the course does not specify any large-scale projects, students will engage in exercises that clarify complex topics like prototypal inheritance and functional programming.
Who is the target audience for this course?
The course is designed for individuals who want to gain a deeper understanding of JavaScript. It is suitable for developers who have encountered JavaScript's more confusing aspects and wish to improve their debugging skills and overall comprehension of the language's inner workings.
Does the course cover ES6 features?
Yes, the course covers ES6 features, including topics such as the 'let' keyword in scopes, classes, and other modern JavaScript features. These lessons help bridge the gap between traditional JavaScript understanding and more modern practices.
What is the time commitment for completing the course?
The course consists of 79 lessons, but the total runtime is not specified. Students should expect to spend additional time beyond watching the lessons to fully understand the complex topics discussed, such as execution contexts, closures, and inheritance.
What important JavaScript concepts are not covered in this course?
The course focuses on understanding JavaScript's 'weird parts' and does not cover all aspects of web development, such as DOM manipulation, AJAX, or asynchronous JavaScript beyond callbacks. It emphasizes the language's core mechanics rather than application development.
How does knowledge from this course benefit a career in software development?
The course provides a deep understanding of JavaScript, which is valuable for debugging and writing efficient code. This knowledge is transferable to other areas of software development, particularly in roles that require a strong grasp of JavaScript, such as front-end development or working with Node.js.