Learn MEAN Stack
4.4 (64 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.
514 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learn MEAN Stack to your Wishlist.

Add to Wishlist

Learn MEAN Stack

MEAN - MongoDB, Express.js, AngluarJS and Node.js
Bestselling
4.4 (64 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.
514 students enrolled
Last updated 7/2017
English
Current price: $10 Original price: $150 Discount: 93% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 10 hours on-demand video
  • 2 Articles
  • 2 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Code a MEAN Project with an Online IDE
  • Understand what the MEAN stack is and when to use it
  • Develop MEAN REST API's with Node and Express
  • Program and configure MongoDB in a MEAN project
  • Develop rich, functional UI's with Angular2 in a MEAN project
  • Work efficiently with amazing MEAN dev tools
  • Scaffold a MEAN UI client project with Angular-CLI
  • ... and much, much more!
View Curriculum
Requirements
  • Before taking this course, a student should ideally (but not absolutely) have some experience in:
  • Creating web UI’s with normal Javascript tools (i.e. jQuery, Bootstrap, ASP.NET, AngularJS, etc.) Programming with a common object-oriented or scripting language (i.e. Java, C#, Python, PHP, etc.) Server-side JavaScript development or some familiarity with Node.
  • ANGULAR1 EXPERIENCE IS NOT REQUIRED!!!
Description

Being a one-trick programming pony doesn’t cut it anymore in today’s tech job market. The more strings you have on your bow, the more in-demand you’ll be. When it comes to web app development, having the know-how to create something fully-functioning from start to finish boosts your employability credentials in a big way.  Thankfully, the MEAN Stack is the tool set that allows you to do just that. Want to get involved? Read on...

Learn a Suite of In-Demand Programming Skills

·         Understand MEAN Stack and how to use it effectively

·         Code MEAN projects with an online IDE

·         Develop MEAN REST APIs with Node and Express

·         Create top-notch UIs with Angular 2

·         Gain the skills needed to become a sought after web developer

Build Full-Stack Solutions for Mobile and the Web

This MEAN Stack online course is designed for any web developer or IT professional who wants to understand and use MEAN Stack for their projects. If you have some experience with an object-oriented/scripting language and JavaScript tools, great. But if you don’t, no worries – we guide you through every part of the process.

You’ll gain a solid foundation of knowledge in using the MEAN Stack (that’s MongoDB, Express, Angular and Node JS) for web and mobile development, with hours of instruction and code-alongs to help you through. You’ll study each component individually, learning how to assemble them to provide a highly efficient JavaScript-based development stack.

That means setting up an online IDE, developing MEAN REST APIs with Node and Express, programming and configuring with MongoDB, developing rich and functional UIs with Angular, scaffolding a MEAN UI client project, and much more.

Plus, we make sure your skills are future-proofed by using Angular 2, the much-discussed rewrite of Angular JS that’s guaranteed to set the market on fire in the coming months. By the time you’ve finished this course, you’ll be more than ready to start working on your own MEAN Stack projects.

What is MEAN Stack?

MEAN Stack is a collection JavaScript-based technologies used for web app development. Namely: MongoDB, ExpressJS, Angular 2 and NodeJS. It is a ‘full stack’ development toolkit, from client and server sides to databases. Basically MEAN Stack allows you to create functional, fun and flawless web applications from beginning to end, with one ‘stack’ of tools.

Who is the target audience?
  • This course was built for web developers who design and build full-stack solutions for mobile and the web.
  • This course is designed for those developers who want to design with the MEAN Stack (with Angular2) as easily as they may with other JavaScript development stacks.
  • Of course, the info presented in this course is just as valuable for architects, testers, and product managers as they too should understand the architecture of the MEAN stack and how development works with MEAN when creating mobile and web solutions.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
186 Lectures
10:10:33
+
Welcome to MEAN
3 Lectures 08:46

Download reference document here

Preview 02:06

In this course we will be introduced to MEAN stack — a full-stack JavaScript solution that helps us build fast, robust, and maintainable web applications. Let's look at each of the technologies in the stack.

What We Will Learn
03:54

Let’s overview the sections of the course so we know what to expect.

Course Specifics
02:46
+
What Does MEAN mean?
5 Lectures 12:19

Not unlike the way LAMP (Linux, Apache, MySQL, and PHP/Python/Perl) came about, MEAN bubbled up in developer camps as a logical, convenient way to build out a Javascript-based web application. 

Preview 03:30

We are looking at MEAN from the side, studying the 4 distinct layers of the stack. Once we have an understanding of each layer, we’ll then discover how the layers dovetail to produce efficiencies for us.

Our Take On MEAN
01:47

We need an understanding of how the MEAN layers all play nicely together.  From a high-level, let’s see how this all works.

Preview 04:05

Section Summary
02:01
+
Node.js & Express
45 Lectures 02:37:21
Section Introduction
01:02

A review of this sub-course's format and an explanation of how it's organized, then a walk thru of the course Learning Objectives

Preview 03:57

Let’s understand the hands-on course project and see a demo of the final product.

Course Project intro
01:43

We can get a Cloud9 account set up if necessary and get our initial project set up in the cloud.

Setup
03:39

We now understand what to expect in the sections of this course and what we can expect to learn. Plus, we’ve got our online development environment all set up and ready to go!

Section Summary
00:41

What are Node & Express and how do we start using them? Let’s begin with the basics.

Discover Node.js
00:13

What are Node & Express and how do we start using them? Let’s begin with the basics.

What are Node.js & Express?
01:36

Let’s see what we can do with Node from the command line.

Try Node from Command Line
02:21

At the command line, we’ll set up a Node.js project, write a simple app in the project, and run it.

Set up a Node.js app
02:36

Let’s make our Cloud 9 project point to a GITHub repo so we can preserve and version our work..

Use GIT with C9.io
04:49

We have a better understanding now of what Node.js is and what it does and what Express is and how it works with Node.js to create Web Applications. We set up a project using the Node console and got our Cloud9 project pointed to a GIT repository for safe keeping.

Section Summary
00:38

In this section we will begin working directly with Express, We’ll get the Express packages downloaded & installed, get our app startup standardized, and define some basic routing.

Work With Express
00:44

Let’s use NPM to get the Express packages we need to begin coding our Express-based Web App.

Get Express set up
08:22

We can configure our project with a standard start script so standards ready and able to deploy our app to any Node service provider.

Create an NPM Start script
02:45

We’ll define some routes with Express and make requests with different URL’s respond properly.

Preview 03:21

In this section we began working directly with Express, We got the Express packages downloaded & installed, got our app starting up appropriately, and defined some basic routing.

Section Summary
00:57

Using a Bootstrap.js template to base our app’s HTML page upon is a quick, easy way to get our app’s UI up and running, yet still allows us to modify the UI to meet our needs.

Kickstart a Node Web App
00:33

Let’s pull in a Bootstrap.js template and easily get our HTML output looking sharp!

Use a Bootstrap Template
06:49

Let’s setup a static directory for serving our resource files with Express.

Configuring Resources
04:56

We can use Bower to manage our UI components just like NPM does for our Node packages.

Manage UI Components with Bower
08:21

We downloaded a cool Bootstrap.js template & got it working in our project so it produces great HTML pages for us.  Then we got Bower set up to manage all of the Bootstrap dependencies that we now have.

Section Summary
00:44

Gulp is a task manager that can take care of all kinds of tedious, mundane tasks for us and make development so much easier. We’ll get Gulp working for us in our project.

Work with Gulp
00:26

Let’s use JSHint so Gulp can automatically check our JavaScript code quality and completeness.

Use JSHint in Gulp
05:10

Wire up Wiredep and get or CSS and Javascript files injected into our HTML files automatically!

Inject dependencies with Wiredep
10:40

We can have all of our custom JavaScript and CSS files injected for us automatically and make our lives so much easier!

Injection with Gulp-Inject
06:59

Nodemon can monitor for changes to our Javascript files. If a file changes Nodemon process them, then restart our server with the changes loaded up. Let’s have this feature!

Watch Changes with Nodemon
04:15

We’re now familiar with some of the great things Gulp can do for us as we build out our Node.js project.

Preview 00:50

Templating Engine: allows Express to build out HTML pages &/or components for us.

Work with Node Templating Engines
00:19

A quick review of 3 different Node.js Template Engines.

Review of Templating Engine Options
02:21

Let’s get EJS Templating Engine set up and working in our project.

Begin with EJS
05:32

We’ll add some EJS code to our project’s HTML page.

Put EJS to Work
06:15

We’ve now familiarized ourselves with templating engines in Node & Express and have chosen EJS as the template engine for our course project.

Section Summary
00:38

Routing is a key part of any web app. Let’s get some more sophisticated routing going in our project.

Preview 00:33

Let’s get a Router into our code and create some new Routes.

Use a Router
07:19

We’ll create some new pages and wire them to our new Routes

New Pages
06:19

Our app.js file is getting a bit cluttered. Let’s move all of our routing code into it’s own .js file.

Separate code into different files
03:28

Let’s wire up our new routes to our new templates and finish the EJS in our templates so our pages display what we want.

Wire our new pages back to Express & Node
08:04

We’ve written routers for our app and moved them into separate, supporting .js files. Our routers and routes are now structured more effectively and our app quality has improved.

Section Summary
00:47

Let’s get MongoDB behind the project we’ve built. We can get MongoDB running, load our data into it, then query that data for display in our web page

Use a Database with Node.js
00:21

We can get MongoDB running and install the MongoDB package into our project.

Get MongoDB setup and installed
03:37

Let’s use our routes knowledge to create a temporary route for inserting our hard-coded events data into MongoDB.

Get Events data ready to be inserted into MongoDB
03:59

Using our new temporary route, we can write insert code to get our data into MongoDB.

Write code to insert our data into MongoDB
06:58

We can query the database directly from our Node.js JavaScript code and display the query results in our web page.

Query MongoDB and display results in our page
04:48

We integrated MongoDB with our Node.js app, loaded our data into a new collection, queried Mongo for that data, and displayed the results in our app’s pages.

Section Summary
00:37

Congratulations, we’ve reached the end of our NOde & Express study! Let’s review the learning objectives we’ve met.

Sub-Course Wrap-Up
06:19
+
Mongo DB
47 Lectures 02:25:58
Welcome to MongoDb
00:32

I’ll explain how this course is organized,including a quick review of the course’s sections & our learning objectives.

Preview 07:03

We’ll view a quick demo of the completed course project so we know what we’ll be building over the course. A list of the features we’ll build to complete our project will also be reviewed.

Our Hands-On Project
01:19

Let’s create a Cloud9 account and set up a MongoDB project by pulling a version from Github. Then, we can install all of the tools we’ll need to build our project.

Setup Our Tools
11:40

We now know what we’ll be learning & how we’ll learn it all. Plus we’re all set up to begin coding our project.

Section Summary
00:38

Let’s begin building our our project with some of the Mongo tools. Our first step is to create a new database and import some data.Learning Objective:Setup & configure a MongoDB instance

Set Up our Project
00:40

Let’s create a new database and import some data.

Import Data with MongoImport
02:46

We can use the Mongo Shell tool to check out our database, its collections, and data.

Use the Mongo Shell
05:33

The Shell Tool is a Javascript editor as well and can execute Javascript on the fly. Let’s use some Javascript in the Shell.

Javascript in the Mongo Shell
01:41

We hit the ground running in this section! We’ve already set up a fully functioning project with data and have begun working with the Mongo Shell Tool.

Section Summary
01:23

Let’s start working with standard database queries and operations, including CRUD.

Start with Queries and Operations
01:11

We can manipulate queries for retrieving data from our database. Let’s begin working with the ‘find’ command on our ‘Users’ data.

Retrieve data with .find()
05:42

Let’s use the .insert() and .save() commands to Create data in a collection in two distinct ways.

Create data with .save() & .insert()
03:13

We can Update existing data in a collection using the .update() command. We can also use $set:{} to add a field to an existing document.

Update data with .update()
04:16

Deleting data is very simple, as long as we know which document we want removed.

Deleting data with .remove()
02:41

Now that our User Data is ready for display, let’s update our app so it will pass User Data from the database thru to the rendered web page.

Display User Data in our App
05:58

We learned about the generality of CRUD operations & how simple they are to use. We then used these operations to shape up our User data and ready it for use in our app.

Section Summary
01:00

Let’s learn to Model data for use in our document-oriented MongoDB database.

Model New Entities
00:49

What are the things we need to be thinking about when we Model our data for use in MongoDB?

Rules for Modeling
03:10

We can work with models that are Simple or go for more Complex structures. Let’s consider speed and data types as we make modeling choices.

Simple & Complex Models
02:40

Let’s use our new knowledge to model the ‘Event’ document for our project.

Modeling ‘Event’ Data
05:52

Registry has some interesting characteristics. Let’s make good decisions when creating a model for our project and consider all scenarios.

Let’s use our new knowledge to model the ‘Event’ document for our project.
05:42

We have learned MongoDB specific data modeling concepts and applied them in creating models for our project’s database.

Section Summary
00:46

Let’s look at how Indexing works in MongoDB and what kind of indices are available.

MongoDb & Indexes
00:42

Indexes are an important part of a properly functioning MOngoDB database. Let’s find out what they do, how they do it, and how we can create them to optimize our database.

Indexing MongoDb
02:00

We can use Mongo commands to see which indices exist and how they’re used in a query.

Using Indexes
01:26

Let’s go through the steps of Creating Indexes and optimize our project with faster queries.

Creating Indexes
03:32

We learned how indices work in MongoDB, why we need them, and how to optimize our existing database by adding indices where they are needed.

Section Summary
00:49

We can build some amazing queries with the Aggregation Framework. Let’s find out how it works.

MongoDb Aggregation Framework
02:07

We’ll discuss data aggregation from 10K ft and learn about pipeline processing & result sets.

Aggregation Concepts
01:30

Let’s walk thru Aggregation Pipeline Stages & see the significance of each. Then, let’s review the Pipeline Operators and see what each one does.

Pipeline Stages & Operators
02:25

We can apply Aggregation Queries and Filters to create our project’s aggregated data. Let’s see how.

Aggregation in our Project
03:02

Now that we have Aggregated Data, we need to use it in our project. We will plug it right into our templates.

Use our Aggregated Data
05:25

We learned how to create Aggregation Queries with the MongoDB Aggregation Framework. We then used Aggregation in our project to create new data from existing records and plugged that data into our HTML templates.

Section Summary
01:40

Replication and Sharding provide the availability and durability that makes MongoDB so great. We’ll look at these concepts from a Developer’s perspective.

Replication & Sharding
01:25

Let’s find out what Replica sets are & how they work.

What are Replica Sets?
02:09

How do Replica Sets stay available? We’ll investigate.

Automated Failover
01:47

Let’s find out what Sharding is and how it is configured.

What is Sharding?
01:19

What considerations are there when we are Sharding our data?

Rules for Sharding data
03:38

We reviewed the steps involved in Replication and Sharding of MongoDB databases and how instances work together when distributed. We can assume that availability and durability standards are provided with these techniques when we design apps for MongoDB.

Section Summary
00:55

Our app has come together nicely. Let’s examine the project as a whole and see how all of the pieces fit together.

Our Web App
06:07

Let’s review the current state of our project and how it got that way.

Our Project’s State
04:59

App.js is the heart of our app. Let’s look into how it drives our application.

Our app.js file
05:14

We’ll look into how the aggregation functions work in our application.

Our Aggregate Queries
02:56

We can now see how the ‘pieces’ of our app fit together and how JSON data is passed from MongoDB thru to the web pages.

Section Summary
03:27

Congratulations! We’ve reached the end of the course. Let’s review the great things we’ve learned.

Sub Course Wrap up
03:49

A walk thru of completed checklists.

Learning Objectives & Project Requirements Review
07:20
+
Angular 2
69 Lectures 03:45:25

This course teaches you how to design and build components, how to use templates to create your application’s user interface, how to extend HTML with directives and data binding, and how routing is done.

Course Introduction
02:13

What is Angular? Why should we use Angular? Why is there an Angular2?

Say Hello to Angular2
04:10

Let’s understand what we’ll do over the life of this course and how we’ll do it.

How this course works
03:02

We can get a Cloud9 account set up if necessary and get our initial project set up in the cloud.

The Course Project
02:00

We now understand what to expect in the sections of this course and what we can expect to learn.

Section Summary
00:52

Before we go head’s down with Angular2, we need to prepare ourselves with some significant background info and a functioning development environment.

Pack Our Lunch
00:59

TypeScript is the language of choice for Angular2. Let’s learn why.

Preview 03:56

We need to get our Cloud9 online IDE set up and ready for development.

Getting the Cloud9 Online IDE
01:24

We’ll code every concept that we learn in our course project. Let’s set it up and get it ready for our first lesson.

Setting Up the Cloud9 IDE
02:02

Modules are a foundational part of Angular2. Let’s be sure to understand what they are and how we’ll use them.

Setting Up The Course Project
08:06

Using Angular 2 Modules
03:47

We are now primed and ready to dive into Angular2.

Section Summary
01:26

In this section we will take a close look at what Angular2 components are and learn the steps involved in creating one.

Angular Components
01:14

Let’s learn what components are and what they’re made of.

Component Defined
02:23

Components consist of 3 parts. Let’s learn what they are and what each part does.

The Component Parts
04:52

Let’s learn the interactions of the 3 component parts and how to stitch them together to create a complete component.

Tying a Component Together
01:59

The App Component is the heart of an Angular2 application. Let’s learn to create it.

The App Component
04:28

With enough ammunition to get an app up and running, let’s learn how to do it.

Bootstrapping an Angular2 App
06:57

We learned enough to get an app up and running. With a very app is simple and very high-level Angular2 knowledg, we’re ready to dive deep into the Angular2 depths.

Section Summary
04:00

We will learn to define the visible aspects of components as HTML within a template.

Building Angular2 UI
02:40

Our view is defined in HTML which can then be inserted into our component’s template.

The Component Template
05:47

We can create a template in a separate file.

Create A Template
02:44

There are 3 steps in using a component as a directive.

The Directive Component
04:25

Binding data from our component’s class to it’s template is easy with interpolation.

Interpolation
04:07

Angular2 has tons of built-in directives that we need.

Angular2 Built-In Directives
09:27

We learned to work with templates within components, to bind data in those components, and how to use components as directives.

Section Summary
03:09

We’ll learn to use Angular2’s property binding to set HTML element properties in the DOM.

Binding in Angular2
01:47

When data changes in our class, we need to reflect the change in our HTML. Let’s learn how this works..

Property Binding
03:42

Certain user interactions with our web page need to update properties in our class. We can use Event Binding to have this happen automatically.

Event Binding
03:49

We can use both Property binding and Event binding at the same time to synchronize class properties and page elements.

2-Way Binding
02:09

Let’s learn to use Pipes to transform bound properties before they are displayed.

Formatting Bound Data with Pipes
03:19

In this section we learned to use Property binding & Event binding and how to combine them for 2-Way binding. We also learned how Pipes help us control the display of our data.

Section Summary
02:08

We will learn several ways to improve upon our components.

Advanced Component Concepts
02:18

Let’s see how to make the most of Angular2’s TypeScript benefits thru use of Interfaces.

Interface & Components
05:08

There is a better way to do styling in Angular2 than simply referencing a CSS file. Let’s learn how!

Styling Components
04:02

Let’s learn to listen to an Angular2 application and react to it’s many events.

Component Lifecycle Events
03:55

We can transform and apply logic to data before we display it in the browser. Let’s see how it works.

Pipe Transform Interface
07:55

In this section we learned to leverage TypeScript strong typing with interfaces, saw how to encapsulate styling within a component, and how to tap into component lifecycle events to trigger operations.

Section Summary
03:10

We will discus how to build components designed to be nested within other components and have these components talk to one another.

Component Composition
01:58

Let’s see how components can work “inside” other components.

Parent/Child Components
05:10

We can use a Nested Component as a Directive. Let’s discuss how this is done.

More Parent/Child Components
02:24

Let’s learn how a Nested Component can take input from its Parent Component.

Property Binding with @Input
02:40

A Nested Component can send data to its Parent Component. Let’s examine this functionality.

Event Binding with @Output
05:38

In this section we learned how Components can nest within one another and still maintain normal data binding.

Section Summary
02:13

We can use Services when we have data or logic that is not associated with a specific view or that we want to share across components.

Preview 01:39

Let’s learn how Dependency Injection can make Services most effective.

Angular2 Dependency Injection
02:11

Services are created quite similarly to Components and Pipes. Let’s see how simple it really is.

Creating Serivices
03:14

Let’s learn to get Services into play by registering them as Providers.

Using Services
02:55

We can leverage Dependency Injection to expose services where they’re needed.

Service Injection
04:35

In this section we learned to create Services, register them as Providers, and how to expose them most efficiently with Dependency Injection.

Section Summary
02:03

We will learn how to use HTTP with observables to retrieve data from the interwebs.

Web Services
01:21

We can use Reactive Extensions (RxJS) to implement Angular2’s Observables instead of simply using Promises.

Observables vs. Promises
02:05

Let’s learn to get Reactive Extensions (RxJS) into play along with Angular2’s HTTP library.

Using Reactive Extensions
02:11

We’ll learn to send HTTP requests in Angular2.

HTTP Requests
06:13

Let’s see how to use Observables to work with data requested via HTTP.

Implementing Observables
02:26

In this section we learned about using Reactive Extensions (RxJS) and it’s Observables instead of relying on Promises. We learned how Angular2’s HTTP library gets us HTTP requests and how to use Observables to handle data in an HTTP response.

Section Summary
02:04

We will learn to define routes for navigate between multiple views in an Angular2 application.

Section Introduction
05:27

In Angular2 routing is component based. Let’s learn to configure routing targets and to define routes for components.

Routing Configuration
03:17

We will discuss the technique of tying routes to user actions for effective navigation within an application

Routes and Actions
04:53

Let’s learn to use the RouterOutlet directive to specify where we want a router component to display its view.

Routes and Views
01:50

Oftentimes routes need to be passed a parameter. Let’s discover how this works in Angular2

Routes and Parameters
05:35

Let’s find out how to do routing with code vs. user interactions. We can implement Angular2’s RouterService to make this happen.

Routes and Code
02:32

In this section we walked through how to configure routes, tie routes to actions, and define where the routed component’s view should appear. We also uncovered some additional routing techniques, including passing parameters to a route and activating a route with code.

Section Summary
04:07

Let's look under the hood of Angular2’s main configuration files and see what they are, what information they contain, and how to use them.

Setting Up Angular2 From Scratch
00:28

Let’s see how tsconfig.json gets our TypeScript compiler working for us.

Configuring the Compiler
02:45

We will take a look at what NPM’s package.json file does for us (a whole lot) and how it’s organized.

Project Dependencies
02:57

Let’s pick apart the imports in our index.html file and see what all of those imports are doing for us.

Core Libraries
00:53

We’ll pat ourselves on the back for completing this course.

Section Introduction
00:33

Let's recap the concepts presented in this course

Review of Concepts
01:37
+
The Real Challenge
6 Lectures 30:24
Section Introduction
01:00

What's going on with 

Angular & Express
01:23

What's going on with Express & Angular2?

Preview 08:10

Let's configure Express to perform for us with a new REST API.

Make Express MEAN & RESTful
08:16

Our project needs to be able to consume a REST API.

RESTful Local Events in Angular2
10:42

Express & Angular2 are now dovetailed.  Let's review how we did it.

Section Summary
00:53
+
MEAN Approaches
5 Lectures 23:31
Section Introduction
00:58

MEAN.io & MEAN.JS are full-stack solutions that helps you build fast, robust, and maintainable production web applications

Preview 03:59

What are our options when considering other frameworks?

Exchangeable Frameworks
07:50

Yeoman is one of the greatest tools for scaffolding MEAN projects.

Scaffolding with Yeoman
09:45

We've seen the differenct ways MEAN can be approached and taken.  We also are now aware of some of the great tools and optional solutions available for use. 

Section Summary
00:59
+
Course Conclusion
4 Lectures 05:35
Section Introduction
02:03

Where do we go from here now that all of the technologies are familiar?

Preview 00:58

Considerations, limitations, advantages, etc.

More comments on MEAN
02:00

Thank you for viewing this course

Thank You
00:34
+
Bonus Material
2 Lectures 01:18
Bonus Lecture: Certificate of Completion
01:04

Bonus Lecture: Course Discounts
00:14
About the Instructor
Stone River eLearning
4.2 Average rating
16,531 Reviews
274,005 Students
201 Courses
270,000+ Happy Udemy Students

At Stone River eLearning, technology is all we teach. If you're interested in programming, development or design - we have it covered. 

Check out our huge catalog of courses and join the over 450,000 students currently taking Stone River eLearning courses. We currently offer 100+ different technology training courses on our Stone River eLearning website and are adding new courses on hot and trending topics every month. A subscription option is available for those with a real passion for learning.