Training - MEAN Stak Developer

A Full-Stack Web Developer is someone who is able to work on both the front-end and back-end portions of an application. The term "stack" is basically a reference to the set of languages or technologies which the developer uses to build sites and/or applications. , MEAN is a full-stack development toolkit.

Overview of the course:

MEAN is a collection of JavaScript-based technologies — MongoDB, Express.js, AngularJS, and Node.js — used to develop web applications. From the client and server sides to databasesA MEAN stack developer uses the MEAN stack.

Pre-Requisites:

Should be familiar with HTML, CSS and JavaScript

Target Audience:

Software developers who want to learn how to leverage this powerful and modern web stack.

Course Content:

Sudents will learn how to create full stack web applications with MongoDB, Express and Angular.js, and Node.js. Attendees build an MVC application using these technologies along with scaffolding provided by MEAN.IO or MEAN.JS.

M - MongoDB, a popular database manager which implements a NoSQL structure.
E - Express.js, a framework which supports and is used to host Node.js projects.
A - AngularJS, yet another framework for building apps. It builds upon the classic html framework style and extends it to web apps.
N - Node.js, the crowning glory. This is a runtime environment, which runs server-side web applications, i.e. it works on the back-end, away from the user's eyes to fetch relevant data or perform operations on the same.

  • Introduction
  • Foundation
    • The Node.js framework
    • Installing Node.js
    • Using Node.js to execute scripts
  • Node Projects
    • The Node Package Manager
    • Creating a project
    • The package.json configuration file
    • Global vs. local package installation
    • Automating tasks with Grunt.
  • HTTP
    • The HTTP protocol
    • Building an HTTP server
    • Rendering a response
    • Processing query strings
    • Using Representational State Transfer
    • Configuring TLS
  • File System
    • Synchronous vs. asynchronous I/O
    • Path and directory operations
    • __dirname and __filename
    • Asynchronous file reads and writes
  • Buffers, Streams, and Events
    • Using buffers for binary data
    • Flowing vs. non-flowing streams
    • Streaming I/O from files and other sources
    • Processing streams asynchronously
    • Configuring event handlers
  • Modules and Unit Testing
    • Modularization
    • The CommonJS and RequireJS specifications
    • Defining modules with exports
    • Modules are singletons
    • Creating a package
    • Module scope and construction
    • Unit testing frameworks
    • What to test and how to test it
    • Building unit tests with Jasmine
  • Express
    • The model-view-controller pattern
    • Building a front-end controller
    • Defining routes
    • Creating actions
    • Using REST
    • Reading POST data
    • Adding middleware
  • Data Sources
    • How Node.js connects to databases
    • RDBMS databases and NoSQL databases
    • Connecting to RDBMS and NoSQL databases
    • Performing CRUD operations
    • Building client requests to web services
  • What is MongoDB?
    • The current SQL/NoSQL landscape
    • Document-oriented vs. other types of storage
    • Mongo's featureset
    • Common use-cases
    • Introduction to JSON
  • Documents and Collections
    • Creating documents
    • Managing documents in collections
    • Iterating over documents
  • Simple Queries
    • Field equality tests
    • Operators available
    • Projections
    • Limiting results and paging
  • Simple Updates and Deletes
    • Field updates
    • Field insertions and removal
    • Document deletion
  • More Complex Types of Queries
    • Existential field values
    • Aggregations and groups
    • Aggregations and groups in hierarchical data
  • Updates and Arrays
    • Altering array field elements
    • Insertion to array fields
    • Removing from array fields
  • Indexing 1
    • The primary index and the _id field
    • Problems requiring an index
    • Defining secondary indexes
    • Compound indexes
  • Indexing 2
    • Index selection
    • Index hints
    • Covering indexes
    • Index storage size
    • Indexes effect insertion and update speeds
  • Mongo RESTful API
    • CRUD operations through REST
    • Using Mongoose with Node.js
  • MapReduce
    • Explanation of MapReduce
    • Types of logic that can be expressed as MapReduce declarations
    • Mapping documents
    • Reducing values
  • Mongo Security
    • Authorization and securing collections, documents
    • The limits of Mongo's authorization scheme
    • Authentication
    • Mongo in the enterprise
  • Mongo Replication and Sharding (optional)
    • Configuring replication
    • Configuring sharding
    • Accessing clustered data from client APIs
    • Latency and consistency in replicated and sharded Mongo
  • Introduction to AngularJS
    • What does AngularJS do for me?
    • Who controls AngularJS?
    • How can I get AngularJS?
  • Our first AngularJS application
    • A basic application
    • Using angular-seed
    • The pieces of the puzzle
      • Two-way data binding
      • Directives
    • How it fits together
      • How much of the page is an Angular application?
    • Model, View, Controller from the AngularJS Perspective
  • Single Page Applications
    • What do we mean by Single Page Application?
    • Creating Angular Modules
    • Using Angular's Routing Service
      • Routing Basics
      • Accessing URL Data
      • Using the $location Service
    • Creating a Skeleton Single Page Application
  • Controllers
    • Where Controllers fit in, and what they do, from Angular’s perspective
    • Managing Scope
    • Setting up Behavior
    • Building a basic controller
    • A more advanced controller
  • Models
    • How to create a model
    • Explicit models
    • Implicit models
  • Views
    • Angular's take on the View: a little bit different
    • Tying a View to a Controller
    • Tying a View to a model
  • Expressions
    • Expressions are lightweight code snippets
    • Expression capabilities
    • Limitations
    • The border between expressions and $eval
  • Filters
    • Standard filters
    • Writing your own filter
    • Tying filters together
  • Scopes
    • What are scopes?
    • What do scopes provide?
    • Scope lifecycle
    • Scopes as glue between controller and view
    • Scope hierarchies
    • Scope and events
  • Angular Forms
    • Angular forms vs HTML forms
    • Angular form controls
    • Form events
    • The form controller
    • Form validation
      • CSS classes for form data
    • Ajax, Data, and Angular
      • High level interactions with servers
      • Low-level server interactions with $http
      • The deferred/promises API
      • Making RESTful Service calls with $resource
    • Directives
      • Teaching HTML new tricks
      • Binding text and attributes
      • Directive processing lifecycle
      • A basic directive
      • Directives and scopes
      • Creating reusable directives
      • Turning directives into components
    • Testing in Angular
      • Unit testing
      • End-to-end testing
      • Angular User Interfaces
  • Overview of MEAN.IO/MEAN.JS (select one)
  • Build a Web-Based CRUD Application using MongoDB, Node.js, Express and Angular.js
    • Application will include the following:
      • Use of MEAN.IO/MEAN.JS
      • Data Storage
      • User Login
      • Server-Side Routes
      • CSS/JS File Combining and Minimization with Grunt Tasks
      • DropBox-style Drag and Drop File Uploads
      • Web Sockets
      • js
      • Additional components as time allows and class interest indicates

Duration:

30 Hrs

Scope of the Course:

The future of the web is dynamic, full stack, real-time JavaScript applications.
There are a lot of product based companies that are in a hunt for MEAN/Full Stack developers, comfortable working with both front-end and back-end databases.

  • Because they have higher efficiency, productive employees and have better allocation of resources from disk space to managing developer experts.
  • MEAN stack eliminates the need for the use of multiple languages. This makes the development of application easy and also helps in the smooth running of the application such as reduced time for a page loading.
  • To start with, unlike SQL databases the MongoDB is a document database. MongoDB does not need any predefined database schemas and rules to establish field regulations this leads to a speedy addition, deletion or editing of data.