w3docs logo
Connexion

Angular - The Complete Guide

Master Angular (formerly "Angular 2") and build awesome, reactive web apps with the successor of Angular.js

Start
  1. Courses
  3. Angular - The Complete Guide

This course starts from scratch, you neither need to know Angular 1 nor Angular 2!

Angular 9 simply is the latest version of Angular 2, you will learn this amazing framework from the ground up in this course!

Join the most comprehensive, popular and bestselling Angular course and benefit not just from a proven course concept but from a huge community as well!

From Setup to Deployment, this course covers it all! You'll learn all about Components, Directives,Services, Forms, Http Access, Authentication, Optimizing an Angular App with Modules and Offline Compilation and much more - and in the end: You'll learn how to deploy an application!

But that's not all! This course will also show you how to use the Angular CLI and feature a complete project, which allows you to practice the things learned throughout the course!

Angular is one of the pmost modern, performance-efficient and powerful frontend frameworks you can learn as of today. It allows you to build great web apps which offer awesome user experiences! Learn all the fundamentals you need to know to get started developing Angular applications right away.

This course uses TypeScript

TypeScript is the main language used by the official Angular team and the language you'll mostly see in Angular tutorials. It's a superset to JavaScript and makes writing Angular apps really easy. Using it ensures, that you will have the best possible preparation for creating Angular apps. Check out the free videos for more information.

TypeScript knowledge is, however, not required - basic JavaScript knowledge is enough.

Why Angular?

Angular is the next big deal. Being the successor of the overwhelmingly successful Angular.js framework it’s bound to shape the future of frontend development in a similar way. The powerful features and capabilities of Angular allow you to create complex, customizable, modern, responsive and user friendly web applications.

Angular 9 simply is the latest version of the Angular framework and simply an update to Angular 2.

Angular is faster than Angular 1 and offers a much more flexible and modular development approach. After taking this course you’ll be able to fully take advantage of all those features and start developing awesome applications immediately.

Due to the drastic differences between Angular 1 and Angular (=Angular 9) you don’t need to know anything about Angular.js to be able to benefit from this course and build your futures projects with Angular.

Get a very deep understanding of how to create Angular applications

This course will teach you all the fundamentals about modules, directives, components, databinding, routing, HTTP access and much more! We will take a lot of deep dives and each section is backed up with a real project. All examples showcase the features Angular offers and how to apply them correctly.

Specifically you will learn:

  • Which architecture Angular uses
  • How to use TypeScript to write Angular applications
  • All about directives and components, including the creation of custom directives/ components
  • How databinding works
  • All about routing and handling navigation
  • What Pipes are and how to use them
  • How to access the Web (e.g. RESTful servers)
  • What dependency injection is and how to use it
  • How to use Modules in Angular
  • How to optimize your (bigger) Angular Application
  • An introduction to NgRx and complex state management
  • We will build a major project in this course so that you can practice all concepts
  • and so much more!
  • Pay once, benefit a lifetime!

Don’t lose any time, gain an edge and start developing now!

Section: Getting Started

1. Course Introduction (0:57)
2. What is Angular? (1:59)
3. Angular vs Angular 2 vs Latest Version (3:49)
4. Angular Setup & First App (7:31)
5. Join our Online Learning Community (1:00)
6. Editing the First App (10:05)
7. The Course Structure (4:00)
8. How to get the Most out of the Course (2:25)
9. What is TypeScript? (2:09)
10. A Basic Project Setup using Bootstrap for Styling (4:27)
11. Where to find the Course Source Code (1:00)

Section: The Basics

12. Module Introduction (0:56)
13. How an Angular App gets Loaded and Started (7:11)
14. Components are Important! (3:08)
15. Creating a New Component (6:51)
16. Understanding the Role of AppModule and Component Declaration (5:15)
17. Using Custom Components (1:12)
18. Creating Components with the CLI & Nesting Components (3:51)
19. Working with Component Templates (3:08)
20. Working with Component Styles (4:02)
21. Fully Understanding the Component Selector (3:50)
22. Assignment: Component Basics (Problem) (1:33)
23. Assignment: Component Basics (Solution) (6:42)
24. What is Databinding? (2:49)
25. String Interpolation (5:19)
26. Property Binding (6:34)
27. Property Binding vs String Interpolation (3:07)
28. Event Binding (4:09)
29. Passing and Using Data with Event Binding (4:37)
30. Two-Way-Databinding (2:47)
31. Combining all Forms of Databinding (1:46)
32. Assignment: Data & Event Binding (Problem) (1:07)
33. Assignment: Data & Event Binding (Solution) (5:12)
34. Understanding Directives (2:17)
35. Using ngIf to Output Data Conditionally (3:52)
36. Enhancing ngIf with an Else Condition (2:46)
37. Styling Elements Dynamically with ngStyle (5:01)
38. Applying CSS Classes Dynamically with ngClass (2:53)
39. Outputting Lists with ngFor (3:43)
40. Assignment: Directives (Problem) (2:15)
41. Assignment: Directives (Solution) (7:06)
42. Getting the Index when using ngFor (2:52)

Section: Course Project - The Basics

43. Project Introduction (1:04)
44. Planning the App (5:33)
45. Setting up the Application (4:31)
46. Creating the Components (9:32)
47. Using the Components (3:15)
48. Adding a Navigation Bar (5:09)
49. Creating a "Recipe" Model (4:33)
50. Adding Content to the Recipes Components (7:41)
51. Outputting a List of Recipes with ngFor (4:37)
52. Displaying Recipe Details (5:52)
53. Working on the ShoppingListComponent (1:49)
54. Creating an "Ingredient" Model (2:35)
55. Creating and Outputting the Shopping List (2:27)
56. Adding a Shopping List Edit Section (3:28)
57. Wrap Up & Next Steps (0:54)

Section: Debugging

58. Understanding Angular Error Messages (4:36)
59. Debugging Code in the Browser Using Sourcemaps (5:32)
60. Using Augury to Dive into Angular Apps (2:01)

Section: Components & Databinding Deep Dive

61. Module Introduction (0:36)
62. Splitting Apps into Components (5:56)
63. Property & Event Binding Overview (1:44)
64. Binding to Custom Properties (5:43)
65. Assigning an Alias to Custom Properties (1:59)
66. Binding to Custom Events (9:05)
67. Assigning an Alias to Custom Events (0:57)
68. Custom Property and Event Binding Summary (2:02)
69. Understanding View Encapsulation (4:59)
70. More on View Encapsulation (2:43)
71. Using Local References in Templates (4:36)
72. Getting Access to the Template & DOM with @ViewChild (5:02)
73. Projecting Content into Components with ng-content (3:22)
74. Understanding the Component Lifecycle (4:54)
75. Seeing Lifecycle Hooks in Action (11:54)
76. Lifecycle Hooks and Template Access (2:33)
77. Getting Access to ng-content with @ContentChild (3:00)
78. Wrap Up (0:49)
79. Assignment: Components & Databinding (Problem) (2:17)
80. Assignment: Components & Databinding (Solution) (12:21)

Section: Course Project - Components & Databinding

81. Introduction (0:50)
82. Adding Navigation with Event Binding and ngIf (7:31)
83. Passing Recipe Data with Property Binding (4:43)
84. Passing Data with Event and Property Binding (Combined) (10:31)
85. Allowing the User to Add Ingredients to the Shopping List (7:22)

Section: Directives Deep Dive

86. Module Introduction (1:23)
87. ngFor and ngIf Recap (3:36)
88. ngClass and ngStyle Recap (2:56)
89. Creating a Basic Attribute Directive (6:42)
90. Using the Renderer to build a Better Attribute Directive (7:04)
91. Using HostListener to Listen to Host Events (3:00)
92. Using HostBinding to Bind to Host Properties (3:17)
93. Binding to Directive Properties (6:43)
94. What Happens behind the Scenes on Structural Directives (3:04)
95. Building a Structural Directive (6:13)
96. Understanding ngSwitch (2:49)

Section: Testing HTTP Request -> Response

97. Testing HTTP Request / Response Introduction (0:54)
98. Laravel Test Setup (5:11)
99. Asserting Against Response Content (6:38)
100. Testing Authenticated Endpoints (5:25)
101. Create a Post Model (8:06)
102. Full Request -> Response Test (6:12)

Section: Course Project - Directives

103. Building and Using a Dropdown Directive (6:25)

Section: Using Services & Dependency Injection

104. Module Introduction (1:39)
105. Why would you Need Services? (2:04)
106. Creating a Logging Service (3:32)
107. Injecting the Logging Service into Components (6:21)
108. Creating a Data Service (6:41)
109. Understanding the Hierarchical Injector (2:40)
110. How many Instances of Service Should It Be? (2:12)
111. Injecting Services into Services (5:13)
112. Using Services for Cross-Component Communication (4:06)
113. Services in Angular 6+ (1:00)
114. Assignment: Services (Problem) (1:44)
115. Assignment: Services (Solution) (9:37)

Section: Course Project - Services & Dependency Injection

116. Introduction (1:23)
117. Setting up the Services (1:15)
118. Managing Recipes in a Recipe Service (4:07)
119. Using a Service for Cross-Component Communication (5:07)
120. Adding the Shopping List Service (5:04)
121. Using Services for Pushing Data from A to B (3:08)
122. Adding Ingredients to Recipes (3:41)
123. Passing Ingredients from Recipes to the Shopping List (via a Service) (7:03)

Section: Changing Pages with Routing

124. Module Introduction (1:26)
125. Why do we need a Router? (1:15)
126. Setting up and Loading Routes (8:01)
127. Navigating with Router Links (5:18)
128. Understanding Navigation Paths (4:54)
129. Styling Active Router Links (5:01)
130. Navigating Programmatically (3:28)
131. Using Relative Paths in Programmatic Navigation (5:09)
132. Passing Parameters to Routes (3:10)
133. Fetching Route Parameters (4:01)
134. Fetching Route Parameters Reactively (7:25)
135. An Important Note about Route Observables (2:42)
136. Passing Query Parameters and Fragments (5:53)
137. Retrieving Query Parameters and Fragments (3:15)
138. Practicing and some Common Gotchas (6:07)
139. Setting up Child (Nested) Routes (4:28)
140. Using Query Parameters - Practice (5:36)
141. Configuring the Handling of Query Parameters (1:50)
142. Redirecting and Wildcard Routes (4:36)
143. Redirection Path Matching (1:00)
144. Outsourcing the Route Configuration (4:40)
145. An Introduction to Guards (1:45)
146. Protecting Routes with canActivate (8:55)
147. Protecting Child (Nested) Routes with canActivateChild (2:51)
148. Using a Fake Auth Service (1:43)
149. Controlling Navigation with canDeactivate (12:28)
150. Passing Static Data to a Route (5:56)
151. Resolving Dynamic Data with the resolve Guard (9:53)
152. Understanding Location Strategies (4:43)
153. Wrap Up (0:51)

Section: Course Project - Routing

154. Planning the General Structure (1:36)
155. Setting Up Routes (7:58)
156. Adding Navigation to the App (1:41)
157. Marking Active Routes (1:31)
158. Fixing Page Reload Issues (2:51)
159. Child Routes: Challenge (1:54)
160. Adding Child Routing Together (4:21)
161. Configuring Route Parameters (6:22)
162. Passing Dynamic Parameters to Links (3:01)
163. Styling Active Recipe Items (1:14)
164. Adding Editing Routes (3:44)
165. Retrieving Route Parameters (3:19)
166. Programmatic Navigation to the Edit Page (4:46)
167. One Note about Route Observables (0:52)
168. Project Cleanup (1:00)

Section: Understanding Observables

169. Module Introduction (4:25)
170. Analyzing Angular Observables (2:15)
171. Getting Closer to the Core of Observables (6:50)
172. Building a Custom Observable (4:46)
173. Errors & Completion (6:39)
174. Observables & You! (1:55)
175. Understanding Operators (8:39)
176. Subjects (8:17)
177. Wrap Up (1:15)
178. Useful Resources & Links (1:00)

Section: Course Project - Observables

179. Improving the Reactive Service with Observables (Subjects) (6:04)

Section: Handling Forms in Angular Apps

180. Module Introduction (1:19)
181. Why do we Need Angular's Help? (2:21)
182. Template-Driven (TD) vs Reactive Approach (1:16)
183. An Example Form (1:32)
184. TD: Creating the Form and Registering the Controls (5:42)
185. TD: Submitting and Using the Form (6:15)
186. TD: Understanding Form State (2:29)
187. TD: Accessing the Form with @ViewChild (3:03)
188. TD: Adding Validation to check User Input (4:14)
189. Built-in Validators & Using HTML5 Validation (1:00)
190. TD: Using the Form State (4:27)
191. TD: Outputting Validation Error Messages (2:23)
192. TD: Set Default Values with ngModel Property Binding (2:15)
193. TD: Using ngModel with Two-Way-Binding (2:48)
194. TD: Grouping Form Controls (3:30)
195. TD: Handling Radio Buttons (3:27)
196. TD: Setting and Patching Form Values (4:42)
197. TD: Using Form Data (4:44)
198. TD: Resetting Forms (1:47)
199. Assignment: Template-driven Forms (Problem) (1:15)
200. Assignment: Template-driven Forms (Solution) (12:17)
201. Introduction to the Reactive Approach (0:40)
202. Reactive: Setup (2:26)
203. Reactive: Creating a Form in Code (4:07)
204. Reactive: Syncing HTML and Form (3:58)
205. Reactive: Submitting the Form (2:15)
206. Reactive: Adding Validation (2:50)
207. Reactive: Getting Access to Controls (3:47)
208. Reactive: Grouping Controls (3:46)
209. Reactive: Arrays of Form Controls (FormArray) (7:31)
210. Reactive: Creating Custom Validators (6:11)
211. Reactive: Using Error Codes (3:20)
212. Reactive: Creating a Custom Async Validator (4:38)
213. Reactive: Reacting to Status or Value Changes (2:11)
214. Reactive: Setting and Patching Values (2:09)
215. Assignment: Reactive Forms (Problem) (1:04)
216. Assignment: Reactive Forms (Solution) (13:48)

Section: Course Project - Forms

217. Introduction (0:59)
218. TD: Adding the Shopping List Form (3:42)
219. Adding Validation to the Form (2:21)
220. Allowing the Selection of Items in the List (4:24)
221. Loading the Shopping List Items into the Form (3:02)
222. Updating existing Items (3:15)
223. Resetting the Form (2:34)
224. Allowing the the User to Clear (Cancel) the Form (1:16)
225. Allowing the Deletion of Shopping List Items (2:52)
226. Creating the Template for the (Reactive) Recipe Edit Form (4:59)
227. Creating the Form For Editing Recipes (5:06)
228. Syncing HTML with the Form (3:52)
229. Adding Ingredient Controls to a Form Array (5:39)
230. Adding new Ingredient Controls (3:38)
231. Validating User Input (5:10)
232. Submitting the Recipe Edit Form (7:30)
233. Adding a Delete and Clear (Cancel) Functionality (4:47)
234. Redirecting the User (after Deleting a Recipe) (1:47)
235. Adding an Image Preview (1:48)
236. Providing the Recipe Service Correctly (1:58)
237. Deleting Ingredients and Some Finishing Touches (3:34)
238. Deleting All Items In A FormArray (1:00)

Section: Using Pipes to Transform Output

239. Introduction & Why Pipes are Useful (2:01)
240. Using Pipes (3:28)
241. Parametrizing Pipes (2:10)
242. Where to learn more about Pipes (1:56)
243. Chaining Multiple Pipes (2:20)
244. Creating a Custom Pipe (6:42)
245. Parametrizing a Custom Pipe (2:36)
246. Example: Creating a Filter Pipe (7:01)
247. Pure and Impure Pipes (or: How to "fix" the Filter Pipe) (4:46)
248. Understanding the "async" Pipe (4:03)
249. Assignment: Pipes (Problem) (1:13)
250. Assignment: Pipes (Solution) (5:10)

Section: Making Http Requests

251. A New IDE (0:43)
252. Module Introduction (1:06)
253. How Does Angular Interact With Backends? (3:09)
254. The Anatomy of a Http Request (2:27)
255. Backend (Firebase) Setup (2:35)
256. Sending a POST Request (10:11)
257. GETting Data (2:56)
258. Using RxJS Operators to Transform Response Data (3:59)
259. Using Types with the HttpClient (5:07)
260. Outputting Posts (2:15)
261. Showing a Loading Indicator (2:03)
262. Using a Service for Http Requests (6:37)
263. Services & Components Working Together (3:28)
264. Sending a DELETE Request (3:27)
265. Handling Errors (6:38)
266. Using Subjects for Error Handling (2:39)
267. Using the catchError Operator (2:13)
268. Error Handling & UX (2:07)
269. Setting Headers (3:18)
270. Adding Query Params (4:01)
271. Observing Different Types of Responses (7:32)
272. Changing the Response Body Type (3:16)
273. Introducing Interceptors (7:24)
274. Manipulating Request Objects (2:32)
275. Response Interceptors (2:46)
276. Multiple Interceptors (4:52)
277. Wrap Up (1:57)
278. Useful Resources & Links (1:00)

Section: Course Project - Http

279. Module Introduction (0:55)
280. Backend (Firebase) Setup (2:03)
281. Setting Up the DataStorage Service (5:32)
282. Storing Recipes (6:39)
283. Fetching Recipes (5:38)
284. Transforming Response Data (4:17)
285. Resolving Data Before Loading (7:31)
286. Fixing a Bug with the Resolver (1:43)

Section: Authentication & Route Protection in Angular

287. Module Introduction (0:52)
288. How Authentication Works (5:01)
289. Adding the Auth Page (6:44)
290. Switching Between Auth Modes (4:02)
291. Handling Form Input (3:44)
292. Preparing the Backend (3:15)
293. Preparing the Signup Request (8:24)
294. Sending the Signup Request (4:36)
295. Adding a Loading Spinner & Error Handling Logic (6:34)
296. Improving Error Handling (5:39)
297. Sending Login Requests (6:00)
298. Login Error Handling (4:28)
299. Creating & Storing the User Data (10:16)
300. Reflecting the Auth State in the UI (9:41)
301. Adding the Token to Outgoing Requests (10:15)
302. Attaching the Token with an Interceptor (8:48)
303. Adding Logout (3:18)
304. Adding Auto-Login (9:55)
305. Adding Auto-Logout (7:39)
306. Adding an Auth Guard (10:56)
307. Wrap Up (1:55)
308. Useful Resources & Links (1:00)

Section: Dynamic Components

309. Module Introduction (1:09)
310. Adding an Alert Modal Component (7:33)
311. Understanding the Different Approaches (2:28)
312. Using ngIf (3:05)
313. Preparing Programmatic Creation (8:27)
314. Creating a Component Programmatically (4:46)
315. Understanding entryComponents (5:06)
316. Data Binding & Event Binding (5:05)
317. Wrap Up (1:25)
318. Useful Resources & Links (1:00)

Section: Angular Modules & Optimizing Angular Apps

319. Module Introduction (0:41)
320. What are Modules? (2:26)
321. Analyzing the AppModule (6:24)
322. Getting Started with Feature Modules (8:59)
323. Splitting Modules Correctly (4:09)
324. Adding Routes to Feature Modules (4:35)
325. Component Declarations (1:58)
326. The ShoppingList Feature Module (4:27)
327. Understanding Shared Modules (8:10)
328. Understanding the Core Module (5:48)
329. Adding an Auth Feature Module (4:22)
330. Understanding Lazy Loading (2:52)
331. Implementing Lazy Loading (12:20)
332. More Lazy Loading (3:02)
333. Preloading Lazy-Loaded Code (3:39)
334. Modules & Services (5:46)
335. Loading Services Differently (8:24)
336. Ahead-of-Time Compilation (9:50)
337. Wrap Up (0:49)
338. Useful Resources & Links (1:00)

Section: Deploying an Angular App

339. Module Introduction (0:52)
340. Deployment Preparation & Steps (3:18)
341. Using Environment Variables (4:44)
342. Example: Deploying to Firebase Hosting (9:01)
343. Server-side Routing vs Client-side Routing (1:00)

Section: Bonus: Working with NgRx in our Project

344. Module Introduction (0:46)
345. What is Application State? (9:07)
346. What is NgRx? (6:55)
347. Getting Started with Reducers (6:44)
348. Adding Logic to the Reducer (5:47)
349. Understanding & Adding Actions (6:16)
350. Setting Up the NgRx Store (4:48)
351. Selecting State (8:51)
352. Dispatching Actions (7:09)
353. Multiple Actions (9:37)
354. Preparing Update & Delete Actions (3:08)
355. Updating & Deleting Ingredients (10:59)
356. Expanding the State (9:17)
357. Managing More State via NgRx (9:52)
358. Removing Redundant Component State Management (3:32)
359. First Summary & Clean Up (5:25)
360. One Root State (11:39)
361. Setting Up Auth Reducer & Actions (8:25)
362. Dispatching Auth Actions (5:53)
363. Auth Finished (For Now...) (6:43)
364. An Important Note on Actions (6:24)
365. Exploring NgRx Effects (3:38)
366. Defining the First Effect (5:19)
367. Effects & Error Handling (8:57)
368. Login via NgRx Effects (9:08)
369. Managing UI State in NgRx (7:30)
370. Finishing the Login Effect (7:11)
371. Preparing Other Auth Actions (4:09)
372. Adding Signup (6:17)
373. Further Auth Effects (6:13)
374. Adding Auto-Login with NgRx (8:16)
375. Adding Auto-Logout (6:31)
376. Finishing the Auth Effects (2:29)
377. Using the Store Devtools (6:20)
378. The Router Store (2:11)
379. Getting Started with NgRx for Recipes (11:03)
380. Fetching Recipe Detail Data (9:14)
381. Fetching Recipes & Using the Resolver (12:00)
382. Fixing the Auth Redirect (2:10)
383. Update, Delete and Add Recipes (15:11)
384. Storing Recipes via Effects (5:52)
385. Cleanup Work (1:58)
386. Wrap Up (2:12)
387. Alternative NgRx Syntax (1:00)
388. Useful Resources & Links (1:00)

Section: Bonus: Angular Universal

389. Module Introduction (3:04)
390. Adding Angular Universal (10:01)
391. Adding Angular Universal with NestJS (6:18)
392. Deploying Angular Universal Apps (1:00)
393. The Remaining Lectures In This Module (1:00)
394. [OPTIONAL] Module Introduction (1:40)
395. [OPTIONAL] Getting Started with Angular Universal (1:31)
396. [OPTIONAL] Working on the App Module (4:02)
397. [OPTIONAL] Adding a Server-Side Build Workflow (4:55)
398. [OPTIONAL] Adding a NodeJS Server (8:26)
399. [OPTIONAL] Pre-Rendering the App on the Server (4:11)
400. [OPTIONAL] Next Steps (1:38)
401. Angular Universal Gotchas (1:00)

Section: Angular Animations

402. Module Introduction (1:03)
403. Setting Up A Starting Project (0:52)
404. Animations Triggers and State (7:11)
405. Switching between States (2:04)
406. Transitions (1:54)
407. Advanced Transitions (5:21)
408. Transition Phases (3:57)
409. The "void" State (6:11)
410. Using Keyframes for Animations (5:32)
411. Grouping Transitions (2:11)
412. Using Animation Callbacks (2:38)

Section: Adding Offline Capabilities with Service Workers

413. Module Introduction (2:09)
414. Adding Service Workers (12:41)
415. Caching Assets for Offline Use (5:28)
416. Caching Dynamic Assets & URLs (7:02)
417. Useful Resources & Links (1:00)

Section: A Basic Introduction to Unit Testing in Angular Apps

418. Introduction (1:18)
419. Why Unit Tests? (2:12)
420. Analyzing the Testing Setup (as created by the CLI) (8:01)
421. Running Tests (with the CLI) (1:59)
422. Adding a Component and some fitting Tests (6:14)
423. Testing Dependencies: Components and Services (6:55)
424. Simulating Async Tasks (9:41)
425. Using "fakeAsync" and "tick" (2:14)
426. Isolated vs Non-Isolated Tests (6:10)
427. Useful Resources & Links (1:00)

Section: Angular as a Platform & Closer Look at the CLI

428. Module Introduction (1:44)
429. A Closer Look at "ng new" (5:18)
430. IDE & Project Setup (2:31)
431. Understanding the Config Files (9:01)
432. Important CLI Commands (5:25)
433. The "angular.json" File - A Closer Look (11:18)
434. Angular Schematics - An Introduction (1:41)
435. The "ng add" Command (4:31)
436. Using Custom "ng generate" Schematics (3:05)
437. Smooth Updating of Projects with "ng update" (2:14)
438. Simplified Deployment with "ng deploy" (5:46)
439. Understanding "Differential Loading" (5:10)
440. Managing Multiple Projects in One Folder (4:35)
441. Angular Libraries - An Introduction (2:51)
442. Wrap Up (1:27)

Section: Course Roundup

443. Roundup (1:33)

Course Instructor

Image

Maximilian Schwarzmüller

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enable me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 1,000,000 students worldwide as well as a successful YouTube channel is the best proof for that.

The most rewarding experience for me is to see how people find new, better jobs, build awesome web applications, work on amazing projects or simply enjoy their hobby with the help of my content. That's why, together with Manuel Lorenz, I founded Academind to offer the best possible learning experience and to share the pleasure of learning with our students.