WEBRip | MP4/AVC, ~239 kb/s | 1280 x 720 | English: AAC, 59.4 kb/s (2 ch), 44.1 KHz | 1.98 GB
Genre: Development / Web Development | Language: English | +Project Files
what every web developer needs to know
What are the requirements?
- Have a basic understanding of how to navigate your platform's terminal or command line
What am I going to get from this course?
- Over 68 lectures and 16.5 hours of content!
- Quickly iterate on code in development, using file watchers that re-compile code on any change
- Easily deploy production-ready asset bundles
- Use a build step in order to allow code transformations so that other languages (such as Less, Sass, CoffeeScript, and TypeScript) can be used in the browser
- Automate common tasks during development and deployment using Node libraries and Gulp
What is the target audience?
- This course is ESPECIALLY for ASP.NET developers who wish to learn more about Gulp, Bower and Node for use in ASP.NET 5
Section 1: Fundamentals: How To Node
Lecture 1 Introduction 04:47
Welcome! This video briefly goes over what we will be learning in this course and what the requirements are.
Lecture 2 Overview 13:26
This video goes a little further and breaks down each of the things we will be learning. We discuss each technology, what it does and why we are learning it.
Lecture 3 Installing Node 14:43
First thing is first: we must get our development environment setup. Here we install Node.js and talk about how we’re going to be using it.
Lecture 5 Node Modules (CommonJS) 19:33
Lecture 6 Node Example 1 16:25
Before moving on to looking at other tools, we introduce many “nodeisms” (including asynchronicity) and the general way that the platform works by working through a simple example.
Lecture 7 Node Example 2 - Part 1 14:41
I don’t think that was enough. Next up, we start with a second example that shows even more of how node likes to work. In this example, we create our own web server using nothing but built-in modules!
Lecture 8 Node Example 2 - Part 2 19:47
And we finally wrap up the last example, finishing our exploration of how node likes to work.
Section 2: NPM: Never manually download a library again
Lecture 9 The Basics 09:45
We introduce the Node Package Manager by showing an example of downloading a global module from the NPM registry that installs a very handy tool on our system that we will be using a lot of.
Lecture 10 Local Modules 15:15
Next up, we explore local modules, how they are installed and how they are located and resolved at runtime.
Lecture 11 (ES2015) Arrow Functions 13:28
I had to sneak this in here… This is an introduction to arrow functions - an ES2015 feature that I wanted to introduce early so I could use it in future examples.
Lecture 12 (Library) Lodash 14:27
A library that I find invaluable is lodash. We take a look at it in this video, so that we can use it in future examples.
Lecture 13 Packages 20:14
NPM packages are vital when using node - either as a backend server, or as a build tool.
Lecture 14 Versioning 07:59
We must have a good grasp on how NPM versions packages (semver), to ensure we have no version conflicts.
Lecture 15 Scripts 16:01
NPM provides a neat utility to place console commands or shell scripts right in our project for re-use. This video explores them.
Section 3: Bower and Less: How to make CSS bearable
Lecture 16 Bower 11:01
This video talks about the simple package manager, Bower.
Lecture 17 Less - Part 1 09:31
This video introduces the Less CSS pre-processor, and shows how we can compile our .less files into .css files using NPM scripts.
Lecture 18 Less - Part 2 19:25
Next up, we explore a handful of features in Less that makes working with it so enjoyable.
Lecture 19 Less - Part 3 19:29
We further our example, and discuss things such as source maps - which allow our browsers to show proper line numbers on our source.
Lecture 20 Less - Part 4 09:48
We wrap up our example and talk more about mixins.
Lecture 21 Introduction 10:17
Lecture 22 Babel 19:33
In order to run ES2015 on our browsers, we need to use a transpiler. This video introduces Babel for that purpose.
Lecture 23 VS Code 04:45
This short video goes over a few things you may run into while using VS Code.
Lecture 24 Variables 20:14
We kick off our discussion on ES2015 by talking about let and const bindings.
Lecture 25 Deconstruction 20:34
Next up, deconstruction!
Lecture 26 Object Literals 10:55
ES2015 gives us some new syntax when working with object literals, and we explore them in this video.
Lecture 27 Classes 12:43
Lecture 28 Symbols 13:16
Symbols are a way to hide members of objects from other source code files. This video breaks them down and discusses their syntax.
Lecture 29 Iterables - Part 1 - Generators 20:31
ES2015 now supports “generators” - known in some languages as “literator blocks”. Very very useful constructs.
Lecture 30 Iterables - Part 2 - Advanced 17:02
Just for fun, let’s see how far we can push the concept of iterables and try to write a simple little collections library similar to lodash!
Lecture 31 Promises 20:52
Promises aren’t a new language feature, but they’re a new type of object we can create in ES2015. We use them to simplify async code.
Lecture 32 Conclusion 01:51
And that’s a wrap on ES2015 features!
Section 5: Gulp: How to automate your life
Lecture 33 Introduction 11:08
This video shows how to install gulp on both our machine, and our specific project.
Lecture 34 Gulp + Babel: Our First Task 18:18
Now we get to the fun stuff, showing how we can incorporate Babel into our Gulp automation.
Lecture 35 Task Dependencies 17:15
This video talks about how dependencies between tasks are managed in Gulp 4.
Lecture 36 Streams 19:44
To understand how gulp works, we must dive into Node streams.
Lecture 37 Object Streams 08:15
Streams and push down objects as well as strings - and this video talks about the kinds of streams Gulp uses.
Lecture 38 Vinyl FS 18:34
Gulp uses a file wrapped called “vinyl-fs”. In this video, we explore it.
Lecture 39 Common Plugins 14:18
Gulp can do a lot of things ,but there’s a handful of things people often use gulp for. This video talks about common things we may want to do.
Lecture 40 Production 17:47
So far we’ve been working with development builds - suitable for working with while in development, not so suitable for deploying to production. This video talks about how we can fix that.
Lecture 41 Watching 19:49
One of Gulp’s best features is its ability to watch files for changes, and perform a task when that happens. This video goes over that feature.
Lecture 42 Organization 11:46
It’s not needed all of the time, but sometimes it’s handy to organize your gulpfile in certain ways if it grows too large.
Lecture 43 Gulp 3 20:08
While hopefully not necessary, I’ve provided a “downgrade” guide for people who for some reason are stuck on the older version.
Lecture 44 Conclusion 01:26
And that’s gulp!
Section 6: Modules: How to organize your assets
Lecture 45 Introduction 13:52
This video begins the discussion on modules. We start off by creating our basic demo app that we will be using to showcase all of our loaders/bundlers.
Lecture 46 ES2015 Syntax 20:43
Although we have no way of loading the modules yet, we can certainly take a look at the syntax required to do so. This video introduces a new bit of ES2015 syntax that will be used to import and export code from one file to another.
Lecture 47 Formats 17:04
AMD? UMD? CommonJS? SystemJS? What is this madness?! This video talks about the different formats that we can have our modules outputted in.
Lecture 48 Example App - Part 1 19:12
We start fleshing out our example app in this video.
Lecture 49 Example App - Part 2 08:17
This video completes our basic example app.
Section 7: Modules: RequireJS
Lecture 50 Introduction 18:02
This video introduces RequireJS and includes it into our example app.
Lecture 51 Shims 14:24
Lecture 52 Optimization 17:24
Next up, we look at how we can do production builds in RequireJS.
Lecture 53 Code Splitting 12:12
Section 8: Modules: Browserify
Lecture 54 Introduction 08:41
This video shows the installation and basic use of the bundler Browserify.
Lecture 55 Gulp 17:16
This video imports browserify into our application, and shows how we can use it within our gulpfile.
Lecture 0 CSS 15:03
Next up, we import our CSS into our bundle using Browserify and a special loader.
Lecture 0 Watching 09:51
Now we implement a watch task in our gulpfile using watchify.
Lecture 0 Conclusion 08:18
And that’s Browserify!
Section 9: Modules: Webpack
Lecture 0 Introduction 15:47
Next up is Webpack! We show a simple example of using Webpack in a small application.
Lecture 56 Loaders 19:07
Loaders are what is responsible for most of Webpack’s magic. Here we talk about how we can import many different kinds of modules using them.
Lecture 57 Example App 20:06
Now we take Webpack and import it into our example app!
Lecture 58 Gulp 19:22
Like we did with browserify, we can get more control over Webpack by executing it from our gulpfile. This video shows Webpack’s node-level API.
Lecture 59 Development Server 12:52
Webpack provides a super-slick, hot-reloading, watching, blazing fast development server. While it’s not for production use, it certainly speeds up your coding!
Lecture 60 Common Plugins 20:49
Next up, we take a look at common plugins we may want to use.
Lecture 61 Conclusion 05:29
And that’s Webpack!
Section 10: Modules: JSPM
Lecture 62 SystemJS 15:53
We kick off our discussion on JSPM by taking a look at its module loader: SystemJS.
Lecture 63 JSPM In our Example App 19:57
Next up, we import JSPM into our example application and use it to load our modules and handle our frontend library dependencies!
Section 11: The End
Lecture 64 Conclusion 04:13
Great Ebooks Collections:Many Thanks to Original uploader.For More Rare Movies