Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add Vue JS 2 - The Complete Guide (incl. Vuex) to your Wishlist.

Add to Wishlist

Vue JS 2 - The Complete Guide (incl. Vuex)

VueJS is an awesome JavaScript Framework for building Frontend Applications! Vue.js mixes the Best of Angular 2 + React!
4.8 (2,265 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
9,617 students enrolled
Last updated 2/2017
English
$19 $190 90% off
30-Day Money-Back Guarantee
Includes:
  • 18 hours on-demand video
  • 29 Articles
  • 78 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Assignments
  • Certificate of Completion
Have a coupon?
What Will I Learn?
Build amazing Vue.js Applications - all the Way from Small and Simple Ones up to Large Enterprise-level Ones
Understand the Theory behind Vue.js and use it in Real Projects
Leverage Vue.js in both Multi- and Single-Page-Applications (MPAs and SPAs)
View Curriculum
Requirements
  • Basic JavaScript Knowledge is Required
  • ES6 Knowledge is a Plus but not a Must
  • Basic HTML and CSS Knowledge is assumed throughout the Course
Description

Hear what students are saying about the course:

He knows how to teach. Splits every details into smaller parts and makes another video for each part. For this reason you don't feel yourself boring while watching videos because lots of them about 2-3 mins not more. One of the best teachers in Udemy that I saw.

The instructor uses an easy-to-follow approach that builds knowledge easily and incrementally.

Very well laid out tutorials that are easy to follow but also run at a pace that doesn't get boring.

About the course

No matter at which Metric you look (Google Trends, Github Stars, Tweets ...) VueJS is the Shooting Star in the World of JavaScript Frameworks - it simply is amazing!

Frontend Frameworks are extremely popular because they give us this reactive, great User Experience we know from Mobile Apps - but now in the Browser! No wonder that Jobs requiring Frontend Framework Skills like VueJS are amongst the best paid ones in the Industry!

You may know Angular 2 and ReactJS, well, VueJS combines the Best of both Frameworks and makes building anything from small Widgets to big, Enterprise-Level Apps a Breeze and a whole lot of Fun! And if you don't know the two mentioned Frameworks: That's fine, too, this Course does not expect any knowledge of any other Frontend Framework - you will learn it all throughout this Course!

### This Course covers it all! ###

We'll start at the very Basics, what Vue.js is and how it works before we move on to more Complex and Advanced Topics but I'll be honest: It's too much to fit it all into one Sentence, so here's what you'll learn in this Course:

  • What is VueJS and Why would you use it?
  • Setting up a Development Environment and Workflow
  • The Basics (including the basic Syntax, Understanding Templates and much more!)
  • Interacting with DOM (Rendering Lists, Conditionally attaching/ detaching Elements ...)
  • Using Components (and what Components are to begin with)
  • Binding to Form Inputs
  • All about DirectivesFilters and Mixins
  • How to make your App more Beautiful with Animations and Transitions
  • How to create an awesome Single-Page-Application (SPA) with Routing
  • How to improve State Management by using Vuex
  • How to Deploy the App
  • And much more ...

And all the accompanied with many Exercises and multiple Course Projects - because it isn't just about seeing Code, it's about using and practicing it!

### Is this Course for you? ###

Now that you know what this Course is about, let's see if this Course is for you!

Here are three Types of Students who will love this Course:

Student #1:

Has some JavaScript Experience and is interested in what this Language can do. He heard and read that JavaScript allows you to create nice Web Applications and enhance existing Web Pages. VueJS is your choice!

Student #2:

He already has some Experience with other Frontend Frameworks like Angular (2) or ReactJS. But either due to interest or disappointment of the existing Frameworks, he seeks some Alternatives - VueJS might be what you were looking for! 

Student #3:

Has Experience with backend Frameworks/ Languages but now also wants to enter the Frontend World. VueJS is an awesome choice here, it's fun, it uses native JS and it's extremely powerful!

Bonus: Student #4

Is disappointed by Angular 2. Does a good Framework need 2 hours of setup? No, certainly not - as VueJS will prove to this Student!

Let's dive into VueJS right now!

Who is the target audience?
  • This Course is for Everyone interested in Frontend Development and Major JavaScript Frameworks
  • This Course is for you if you want to create Reactive Applications, which run in the Browser
  • This Course also targets Students who prefer a native JavaScript Framework which makes Getting Started much simpler than Angular 2
  • Displeased with Angular 2? VueJS is for you!
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 329 Lectures Collapse All 329 Lectures 18:11:39
+
Getting Started
7 Lectures 19:56

Welcome to this Course! In this lecture you'll see why that was exactly the right choice!

Preview 03:08

We know the WHAT and WHY - now let's jump right into it! This lecture shows how to get started with VueJS and create first simple App with it.

Preview 04:45

Let's extend our first little Application a bit and add more features to it.

Preview 04:12

We created our first Application - what else does this Course offer? You'll learn in this video!

Preview 03:44

There are a couple of Resources you can use throughout this Course - learn more about them in this lecture.

Preview 01:55

Don't want to use JSFiddle? No problem, you can follow along with a local setup as well!

Setup VueJS Locally
02:02

Module Resources & Useful Links
00:10
+
Using VueJS to Interact with the DOM
25 Lectures 01:03:01

Let me give you a brief introduction to this module.

Module Introduction
00:45

It's key to understand HOW VueJS interacts with the DOM. It does so, by using Templates. This lecture explores how this basic connection works and how you can use it.

Understanding VueJS Templates
02:34

VueJS apps have this strong connection between your templates ("the DOM") and your business logic. The latter resides in the Vue Instance. This lecture therefore explores both.

How the VueJS Template Syntax and Instance Work Together
02:42

It's key to understand how you may access data in the Vue Instance. It actually proxies all the properties you set up in the data property. But let's dive deeper into this topic, in this lecture.

Accessing Data in the Vue Instance
01:49

So far, we always used String Interpolation. That doesn't work if we want to bind to any element attributes (like <img src="...">). This lecture therefore explores our alternatives.

Binding to Attributes
02:42

Directives are another powerful feature, VueJS offers us. This lecture explains what Directives are and how you may use some of the built-in ones.

Understanding and Using Directives
01:27

Normally you want your page content to be updated by VueJS. But if you don't want that, v-once is a handy directive to suppress this functionality. Learn more, in this video.

Disable Re-Rendering with v-once
01:41

Did you already try to output HTML code (instead of plain text)? That probably won't work with normal String Interpolation! But no worries, there is a way to still output HTML - this lectures shows you how.

How to Output Raw HTML
02:43

You learned a lot about the VueJS 2 Template Syntax and how you may output Data to your template, hence rendering it on the page. Time to practice this in this first Assignment!
Time to Practice - Outputting Data to Templates

So far we learned how to output data. That's nice. But in a real application, you'll also want to listen to User/ DOM Events. VueJS has a Directive for that and this video explains how it works.

Listening to Events
01:50

It's nice to be able to listen to an Event but maybe you also want to use the Event Data? Nothing easier than that, let this lecture explain how to access the Event Data!

Getting Event Data from the Event Object
02:36

Not satisfied with the default Event Object you get supplied by the DOM/ JavaScript? You can also pass your own Data - learn more in this lecture!

Passing your own Arguments with Events
01:53

Sometimes you want to change the default behavior of an Event. VueJS offers you Event Modifiers as a nice Tool to achieve that.

Modifying an Event - with Event Modifiers
03:23

You want to listen to a specific Key being pressed? VueJS makes that easy - with Key Modifiers. Learn more, in this lecture!

Listening to Keyboard Events
02:03

More important Steps towards mastering VueJS Template Syntax have been taken. Time to use all the new Knowledge about how to use Events in a VueJS Application!
Time to Practice - Events

You're not limited to outputting properties or calling methods in your templates. You may also run (simple) JavaScript code there as this Lecture will show you.

Writing JavaScript Code in the Templates
03:19

We all know it since Angular (1), VueJS also has it. Whilst the standard flow of data is unidirectional, you may also use Two-Way-Binding and this lectures dives into how to do that.

Using Two-Way-Binding
01:49

Not all properties you use are static or updated manually. Some need to react to changes of other properties. Computed properties are there to help! Learn how to use them, in this video!

Reacting to Changes with Computed Properties
09:32

Computed Properties should be your preferred choice, but sometimes you want to execute some specific code when one part of your application changes. You can Watch for such changes, this lecture explores how that works.

An Alternative to Computed Properties: Watching for Changes
03:53

We covered a lot of the basics until now. We repeatedly used v-bind and v-on for that. Well, we can save some time there - and this lecture shows how.

Saving Time with Shorthands
01:26

In the last Lectures, you learned a lot about how VueJS handles Reactivity. Time to put this to Practice and do some Exercises on it!
Time to Practice - Reactive Properties

Often times, you not only want to change the data you print to the screen, but also some styling. Well you can do that as this lecture will show.

Dynamic Styling with CSS Classes - Basics
04:22

Now that we covered the basics about using CSS Classes dynamically, it's time to dive deeper and understand how else we may use that feature.

Dynamic Styling with CSS Classes - Using Objects
01:35

Let's finish the short trip in the world of dynamic CSS Classes by having a look at some other tools we can use in conjunction with them.

Dynamic Styling with CSS Classes - Using Names
03:27

So far, we learned how to style elements dynamically when using CSS Classes. Maybe you don't want to use CSS Classes though. This lecture explores how you may directly manipulate the Styling of an element.

Setting Styles Dynamically (without CSS Classes)
03:15

As with CSS Classes, we can also use the Array Syntax to apply custom Styles directly to elements. Have a look at this lecture to learn more about it.

Styling Elements with the Array Syntax
01:14

A lot has been covered in this Course Module. In the last Lectures, you learned how you may dynamically change the CSS Classes and Styles of Elements. Time to Practice this in this Assignment!
Time to Practice - Styling

Let me summarize and wrap up this module for you.

Module Wrap Up
00:44

This lecture contains all the JSFiddle Links used in this Module as well as some other useful links for you to dive deeper.

Module Resources & Useful Links
00:17
+
Using Conditionals and Rendering Lists
13 Lectures 24:04

Let me introduce you to this Module.

Module Introduction
00:48

Sometimes you don't want to display certain parts of your DOM at all times. Sometimes a specific condition should control that. VueJS makes that easy by offering you the v-if directive. Learn more about it, in this video!

Conditional Rendering with v-if
03:37

v-else-if in Vue.js 2.1
00:09

v-if can be used with two slightly different Syntaxes. Let's have a look at the alternative in this lecture.

Using an Alternative v-if Syntax
01:36

v-if attaches and detaches elements to/ from the DOM. Sometimes you only want to set the CSS display property to "none" though. v-show is the tool you want to choose for that task!

Don't Detach it with v-show
01:43

A common task is to output an array of data. How do you do that with VueJS? It's very easy, let's explore it in this lecture.

Rendering Lists with v-for
02:25

What if you not only want to loop through all your items but also need the Index of the current iteration? VueJS got you covered as this lecture will show you.

Getting the Current Index
01:51

As with v-if, we can use a different Syntax with v-for. Let's take a closer look in this lecture.

Using an Alternative v-for Syntax
01:10

What if your data source isn't an array but a JavaScript object? You may still use v-for as this lecture will explain.

Looping through Objects
04:44

What if you only want to loop through all numbers from 1 to n? Do you need to create a new array for that? No, as this lecture shows, VueJS offers a shortcut for such a task.

Looping through a List of Numbers
00:57

In some cases, VueJS needs to keep track of the Elements you're rendering with v-for. You can therefore assign keys, this lecture shows you how.

Keeping Track of Elements when using v-for
04:08

Conditionals and Lists are key features of VueJS and constructs you'll probably use in every VueJS app. Time to practice them.
Time to Practice - Conditionals & Lists

Let me summarize and wrap up this module.

Module Wrap Up
00:51

This lecture contains all the JSFiddle Links used in this Module as well as some other useful links for you to dive deeper.

Module Resources & Useful Links
00:05
+
First Course Project - The Monster Slayer
16 Lectures 43:19

Let me introduce you to this Course Project and challenge you to build it on your own before seeing me build it!

Introduction & Challenge
02:54

Before writing any code, we need to set up the Course Project. I'll do that in this lecture.

Setting up the Course Project
02:37

Let's start by setting up the Vue Instance and start working on the basic interface. The Healthbars make for a good start, so let's start on that.

Creating the Vue Instance and Styling the Healthbars
05:16

We got a lot of buttons to press, but not all buttons should be pressable at all times. So let's use our knowledge about Conditionals to control this.

Showing the Player Controls Conditionally
02:02

Time to start working on those methods, such that the buttons actually do things. A good start is to allow the user to actually start a new game. This lecture shows my solution on this.

Implementing a "Start Game" Method
01:53

The game has started, that is great. But now it would be very useful if we could do more than just watch it. So let's add an additional method - one which allows us (the player) to attack.

Implementing a "Attack" Method
08:03

Whilst creating applications, you're going to face the point of time where your code isn't optimal anymore. In such a case, you should consider refactoring. This lecture dives into that.

Write better Code - Time for Refactoring!
04:52

After refactoring, let's continue working on our base mechanics of this game. Time to add an additional action the user can execute!

Implementing a "Special Attack"
02:11

On we go, time to allow the player to heal himself.

Implementing a "Heal" Method
02:21

We got a couple of actions now, time to finish these buttons and make them all work as intended.

Finishing the Action Buttons
00:59

We got plenty of actions happening during our game. It's hard to keep track but thankfully we learnt how to store data in lists and then output such lists. So let's have a look at this, in this lecture.

Creating an Action Log
02:41

Time to output the Log we created in the last lecture. We learnt about a very useful directive to do that. Do you remember?

Printing the Log (v-for)
02:19

Time for some final touches to make the log work as intended!

Finishing the Log
01:57

Right now, it's hard to tell which action comes from a user and which comes from the monster. Let's use our knowledge about dynamic CSS classes to change this!

Styling the Log Conditionally
01:44

We finished the Application! Let me wrap up what we achieved in this Module!

Wrap Up
01:28

Full Application Code
00:02
+
Understanding the VueJS Instance
16 Lectures 53:34

Let me introduce you to this module.

Module Introduction
01:04

I already dived into some of the basics of the VueJS instance in the other modules. Let me summarize some core things you need to know about it.

Some Basics about the VueJS Instance
02:58

So far, we only used one Vue Instance. But you're not limited to that! This lecture explores how you may use multiple Vue Instances in your app.

Using Multiple Vue Instances
02:52

We only used the Vue Instance from inside of it - that means, we only used its data, methods etc. inside of the Instance. You can also access these things from outside as this video will show.

Accessing the Vue Instance from Outside
03:29

Isn't that interesting, that we're able to access properties etc. from outside - directly on the Instance itself? This video explains how VueJS does that.

How VueJS manages your Data and Methods
04:01

We already learned about $el and $data, but as these two properties are so important, let's dive deeper into them in this lecture.

A Closer Look at $el and $data
04:55

Sometimes you want direct access to certain elements in your Template. VueJS can do that for you, all you need are some $refs. Learn more about that concept in this video!

Placing $refs and Using them on your Templates
05:47

We covered a lot, but it's pointless to cover every single option and method VueJS offers you. But you certainly need to know where to look for it! This video shows it.

Where to learn more about the Vue API
00:58

Until now, we always used "el" to get a Template. There are other options as this video shows.

Mounting a Template
06:42

No worries, I got a whole section on Components, but here's a great place to get started with them and understand why a component-driven approach might make sense!

Using Components
04:56

VueJS gives you different ways of using Templates, some of them have limitation as this video will teach you.

Limitations of some Templates
02:35

Did you ever wonder how VueJS knows when to update what? And how it does that in a high-performance way? That video explores this question.

How VueJS Updates the DOM
03:24

Each Instance (and Component) in VueJS follows a certain lifecycle with events you can tap in to run your code. This lecture explains this lifecycle and which hooks you may use when.

The VueJS Instance Lifecycle
03:12

Let's have a closer look at this VueJS Instance Lifecycle and see all the hooks in action.

The VueJS Instance Lifecycle in Practice
05:39

Let me wrap up and summarize this module.

Module Wrap Up
00:54

Module Resources & Useful Links
00:08
+
Moving to a "Real" Development Workflow with Webpack and Vue CLI
12 Lectures 29:55

Let me introduce you to this Course Module.

Module Introduction
01:33

Until now we used a simple local setup or JSFiddle. I'd argue that we want a better setup, including a local development server (which runs our app). Why? This video explains it!

Why do we need a Development Server?
02:47

Why do we need a Development Workflow? And what is that to begin with? This lecture explains it!

What does "Development Workflow" mean?
03:51

VueJS also has its own CLI. That CLI doesn't have super-many features, but it has one major one: It allows us to quickly create a new Vue Projects from a couple of prepared templates.

Using the Vue CLI to create Projects
02:35

Time to use the CLI! For that, we'll first install it (and learn its prerequisites) before we dive into our first project!

Installing the Vue CLI and Creating a new Project
04:18

We chose the simple Webpack template - a great template for starter Projects (though also useable for bigger ones!). Let's have a look at all the folders and files which were created by the CLI.

An Overview over the Webpack Template Folder Structure
03:40

Do you notice these strange ".vue" files? What are they? How do they work? This video takes a closer look.

Understanding ".vue" Files
06:45

There is an Object in the ".vue" File - let's have a closer look at it in this lecture.

Understanding the Object in the Vue File
01:11

Having a Development Workflow/ Build Process is great, but in the end, you probably want to deploy it. For that, the Template we use also has a Production Workflow. This video shows how to use that.

How to Build your App for Production
00:49

Let me summarize and wrap up this Module.

Module Wrap Up
01:11

Want to learn more about ".vue" Files and the CLI? Here's the right place!

More about ".vue" Files and the CLI
00:50

It's going to happen at some time: Your app doesn't behave the way it should behave. In such a case, debugging it is the thing you want to do. Let's learn how that works in your VueJS project (created with CLI).

Debugging VueJS Projects
00:24
+
An Introduction to Components
13 Lectures 39:50

Let me introduce you to this course module on Components.

Module Introduction
01:04

The title says it all: Time to understand what Components are, how they work and how you can use them.

An Introduction to Components
04:56

Components extend the VueJS Instance. Therefore, they share the same fields (like "methods", "computed" etc.). There's one important difference regarding the "data" field though. This lecture explains which difference that is.

Storing Data in Components with the Data Method
04:04

You can register Components either on application-level or locally in a specific component. This lecture explains both approaches and which differences you should take into account.

Registering Components Locally and Globally
02:50

You probably noticed, that we always have the App.vue file in our setup. What's this Object in this file all about? This lecture explains it.

The "Root Component" in the App.vue File
03:21

Finally! It's time to create a new Component on our own. This lectures teaches you how that works.

Creating a Component
04:24

We created a new Component, now how do we use it? This lecture dives into that question and shows how to use the Component.

Using Components
05:32

Components are an extremely useful and versatile feature of VueJS. In this Assignment, you can test your knowledge and practice the things you learned about them.
Time to Practice - Components

Right now, our Folder Structure isn't very good. It's quickly getting crowded and we certainly don't even want to think about building a more complex application with such a structure! Time to change that - in this video.

Moving to a Better Folder Structure
02:42

Alternative Folder Structures
00:19

If you're using .vue files, you're pretty free regarding the choice of your component selectors/ tags. So what are good names? This lecture explains some things you might want to take into consideration.

How to Name your Component Tags (Selectors)
04:31

When using .vue files, you can scope the styles of that file to the component contained in that file. Sounds awesome? It is - let's learn more in this video!

Scoping Component Styles
05:04

Let me wrap up and summarize this module.

Module Wrap Up
00:50

Module Resources & Useful Links
00:13
+
Communicating between Components
14 Lectures 38:41

Let me introduce you to this course module.

Module Introduction
00:45

Let's first understand which problem we actually need to fix before diving into the solutions. This lecture sets up a simple projects and shows what our goal is.

Communication Problems
02:52

One of the most common forms of passing data is to use "props". "props" are used to pass data from a parent to a child component. Learn more about it in this lecture.

Using Props for Parent => Child Communication
03:10

How can and should you name your props? Let's have a look at this question in this lecture.

Naming "props"
01:09

We're able to pass "props". Great! Now let's understand how may use them in the receiving (child) component.

Using "props" in the Child Component
01:28

In most cases, we can't work with any random type of prop. We expect a string, number or whatever we need. For that, we can set up "props" validation. This lecture explores how that works.

Validating "props"
04:56

We could use "props" to pass data from the parent to the child component. What if we want to do it the other way around? That's also possible, though not with "props". Learn which other option you have, with this module.

Using Custom Events for Child => Parent Communication
05:55

To understand when to use "props" and when to use custom events, it's key to understand how data flows in a VueJS app. This lectures explores this a little bit more.

Understanding Unidirectional Data Flow
01:07

An alternative to custom events would be callback functions you pass as "props" from parent to child component. Learn more about this alternative in this lecture.

Communicating with Callback Functions
02:23

So far we only looked at parent<=>child relations. What if we got two (or more) sibling components which want to talk with each other? Let's explore one way of enabling this in this lecture.

Communication between Sibling Components
06:24

Building chains of "props" and events can quickly become cumbersome. Fortunately, there's an alternative: Using an Event Bus. Learn more about that in this lecture.

Using an Event Bus for Communication
05:31

We learned about the Event Bus, let's now dive a little deeper and see what else we can do with it.

Centralizing Code in an Event Bus
02:14

Being able to create Components is great, but having them communicate with each other is extremely important, too. This Assignment allows you to practice just that!
Time to Practice - Component Communication

Let me wrap up and summarize this module.

Wrap Up
00:40

Module Resources & Useful Links
00:07
+
Advanced Component Usage
14 Lectures 26:26

Let me introduce you to this course module on advanced component usage.

Module Introduction
00:38

In order to show some advanced component concepts, we'll need a tiny project to work with. Let's set it up in this lecture.

Setting up the Module Project
03:00

What if you wanted to pass more complex content from a Parent to a Child component? Let's first have a look at a suboptimal solution.

Passing Content - The Suboptimal Solution
02:19

For passing (HTML) content from a Parent to a Child Component, VueJS offers a concept called "Slots". Let's explore this concept in this lecture.

Passing Content with Slots
00:42

When passing and distributing Content via Slots, the question is: Which Styles do apply and where does the Content get compiled? Let's dive into these questions now.

How Slot Content gets Compiled and Styled
03:02

Sometimes you really want the highest amount of control over how and where your Content should be displayed in the receiving Component. Named Slots help you with this as this lecture will explain.

Using Multiple Slots (Named Slots)
02:49

When using Slots, VueJS has some Default assumptions - learn more about them in this lecture.

Default Slots and Slot Defaults
02:01

Time to sum up the things we learned about Slots in this module thus far.

A Summary on Slots
00:45

What if you had an Application where you had multiple Components displayed conditionally in the same place? VueJS has a concept called "Dynamic Components" which should help you with that!

Switching Multiple Components with Dynamic Components
05:31

When using Dynamic Components, it's key to understand how they behave and should be used. This lecture dives into this.

Understanding Dynamic Component Behavior
02:07

What happens to Dynamic Components which are currently not rendered? This lecture explores this question and shows a way to change the default behavior.

Keeping Dynamic Components Alive
00:58

Due to their dynamic nature, Dynamic Components ship with some extra Lifecycle hook - let's dive deeper in this lecture.

Dynamic Component Lifecycle Hooks
01:17

You learned a lot about Components! Now it's time to also take that advanced knowledge and challenge yourself in this assignment.
Time to Practice - Slots and Dynamic Components

Let me wrap this module up.

Wrap Up
01:10

Module Resources & Helpful Links
00:07
+
Second Course Project - Wonderful Quotes
12 Lectures 29:15

Let me introduce you to this course module and the Application we're going to build here!

Module Introduction
01:35

Let's start by setting up the base Project we're going to use throughout this module.

Setting up the Project
01:21

Now that the Project is set up, it's time to initialize the VueJS Application - let's do this in this lecture.

Initializing the Application
01:28

What will our Application certainly need? Components! So let's set them up in this lecture!

Creating the Application Components
04:04

Time to use the things we learned about passing data - by adding Slots and Props to our Application.

Passing Data with Props and Slots
02:13

Displaying Quotes is nice, but we certainly want to be able to add new ones. This lecture dives into this.

Allowing Users to Create Quotes with a NewQuote Component
04:08

How do we inform our App that a new Quote was added? Well, a Custom Event sounds like a good idea, so let's add this functionality to the App.

Adding Quotes with Custom Events
03:34

Not the most important part of the Application, but hey - let's display a Info Box!

Adding a Info Box
01:06

Adding and viewing Quotes is a great thing, but sometimes we want to get rid of Quotes. This lecture dives into this topic.

Allowing for Quote Deletion
03:40

Our App has a Quote Limitation. Time to add a visual display of it.

Controlling Quotes with a Progress Bar
03:51

Time to finish the App and control the Application State!

Finishing Touches and State Management
02:13

Module Resources
00:02
11 More Sections
About the Instructor
4.7 Average rating
15,981 Reviews
54,444 Students
9 Courses
Professional Web Developer and Instructor

Experience as Web Developer

Starting out at the age of 13 I never stopped learning new programming skills and languages. Early I started creating websites for friends and just for fun as well. This passion has since lasted and lead to my decision of working as a freelance web developer and consultant. The success and fun I have in this job is immense and really keeps that passion burningly alive.

Starting web development on the backend (PHP with Laravel, NodeJS) I also became more and more of a frontend developer using modern frameworks like Angular 2 or VueJS 2 in a lot of projects. I love both world nowadays!

As a self-taught developer I had the chance to broaden my horizon by studying Business Administration where I hold a Master's degree. That enabled me to work in a major strategy consultancy as well as a bank. While learning, that I enjoy development more than these fields, the time in this sector greatly improved my overall experience and skills.

Experience as Instructor

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 enables me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses as well as a successful YouTube channel is the best proof for that.

Whether working as development instructor or teaching Business Administration I always received great feedback. The most rewarding experience is to see how people find new, better jobs, build awesome web applications, acquire amazing projects or simply enjoy their hobby with the help of my content.

Report Abuse