• In this module, you will learn:
  • Basics of CSS3, CSS rules
  • Comments, Colors, background, border, margin, padding, height, and width
  • CSS selectors and properties
  • Inline, internal, and external CSS
  • Font styling, web safe fonts – Texts, icons, links
  • The ‘Box model’
  • CSS sizing methods
  • CSS static, relative, and absolute positioning systems
  • CSS float and clear 
  • Pseudo classes and pseudo elements
  • Class vs. ID
  • Opacity, Navigation bars, Dropdowns
  • CSS rule conflict resolution. specificity, and implementing style hierarchy
  • Images and forms styling
  • Transitions, animations, pagination, 2D and 3D transforms
  • Responsive web design 
  • The grid system
  • Flexbox, media queries
  • CSS coding best practices

• In this module you will learn:
  • The mobile-first paradigm
  • Wireframes in the design phase
  • Twitter Bootstrap – Grid System
  • How to install the Bootstrap framework
  • Bootstrap containers to layout website easily
  • Other Bootstrap components
  • Bootstrap carousels
  • Bootstrap cards 
  • Bootstrap navigation bars
  • Bootstrap themes
  • Font-awesome

• The topics covered in this module are:
  • ECMAScript
  • JavaScript vs Java
  • Popularity and Importance
  • Basics of JavaScript
  • JS Statements
  • JS functions
  • Adding JS to your website
  • Document Object Model
  • Manipulating DOM
  • Events
  • Exception Handling
  • Forms and JS

• The topics covered in this module are:
  • Variables, data types, and operators in JavaScript 
  • Statements, syntax, comments, and events
  • Loops, control, and conditionals 
  • JS forms
  • Document Object Model (DOM)
  • Browser Object Model (BOM)
  • JS functions
  • Scope and closures
  • Object-Oriented Programming (OOP) 
  • JS objects and prototypes – keyword
  • Cookies
  • Exception handling
  • Arrow functions
  • Promises
  • Template string, default parameters, spread and rest operator, destructuring, generators, Set, Map, WeakSet, WeakMap 
  • HTML APIs
  • Separation of concerns, refactoring, debugging, and coding best practices

• We will be covering
  • Serving and retrieving data to a website
  • Asynchronous loading – Set up and handle AJAX requests and responses
  • JSON
  • XML
  • Processing JSON data
  • JSON vs. XML

• Why Angular?
• Features in Angular
• History of Angular (AngularJS vs Angular)
• Angular Architecture
• Building blocks of Angular
• How to think in Angular
• Getting started with a basic Angular app
• Project structure best practices
• Overview of our course project

• Understanding modules vs components vs directives
• Lazy loaded modules
• Data Binding with components
• Property/Event Binding
• Component Lifecycle

• Templates and View Encapsulation
• Accessing DOM element programmatically
• Dynamic components
• Content projection

• Services and dependency injection
• Single vs multiple instances of service
• Reactive programming concept
• Observable vs promise
• RxJS library introduction
• Use cases for Angular services

• Parent-child component communication
• Component communication using services
• Connecting to REST APIs through HTTP/HTTPS
• Handling API response and manipulating it
• Handling errors
• HTTP Interceptors

• Structural vs attribute directives
• Built-in directives examples like “ngIf”,”ngFor”,”ngSwitch”, etc.
• Custom directives
• Angular Material introduction
• Features of Angular Material
• Styling Angular app using Angular Material

• Pipes
• Pure vs Impure pipes
• Basic built-in Pipes
• Custom Pipes
• Introduction to forms
• Template-driven and Reactive forms
• When to use which form?

• Creating a basic form
• Accessing form state
• Form validation
• Error handling
• Set values programmatically
• Grouping controls in a form
• Submit/Reset Forms

• Creating a basic form
• Accessing form state
• Form validation
• Error handling
• Set values programmatically
• Grouping controls in a form
• Submit/Reset Forms

• Routers – Why and How?
• Navigating with Routers
• Pass and fetch query parameters in routes
• Nested Routes
• Securing routes (Route Guards)
• Use cases for Route Guards
• Routing Strategies

• How do we test code in Angular?
• How to write unit test cases in Jasmine?
• Writing unit test cases for a few common scenarios in Angular
• How to debug Angular code?
• Tools/utilities to speed up debugging Angular code

• Designing scalable and secure Angular app
• Deployment
• Web Accessibility
• Internationalization
• Angular Universal
• Angular Elements
• Service workers or progressive web app
• Angular Schematics

Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value. A string is a sequence of characters like – “hello“.

• In this session, we will learn about:
  
  • Arrays
    
    • Static arrays
    • Dynamic arrays
    • 2D arrays, row-major and column-major mapping, matrices
    • Strings
  • LinkedList
    
    • Singly LinkedList and its operations
    • Doubly LinkedList and its operations
    • Circular LinkedList and its operation 

The stack is a linear data structure that is used to store a collection of objects. It is based on Last-In-First-Out (LIFO).

• In this session, we will be discussing about:
  
  • Stacks
    
    • Implementations- using arrays, using linked lists
    • Operation
    • Applications
  • Queues
    
    • Implementations- using arrays, using a LinkedList, using two stack
    • Circular queues
    • Priority queues 

A tree is a non-linear data structure where data objects are organised in terms of hierarchical relationships. In this week’s session, we’ll be discussing them one by one.

• In this week, we will discuss about 
  • Trees.
    
    • Binary trees, their representations
    • Pre-order, In-order, post-order traversal
    • Binary search trees
    • AVL trees

Heap and Trie are special cases of trees. A heap is a special tree-based data structure in which the tree is a complete binary trees.

• In the session, we will discuss about
  • How to solve the longest word in the dictionary problem using tries.
  • Heaps
    
    • Min Heap
    • Max Heap
    • Find K largest (or smallest) elements in the array
  • Tries
    
    • Longest Word in Dictionary Problem

A graph is a data structure that consists of a finite set of vertices, also called nodes and a finite set of ordered pairs of the form (u, v) called edges.

• In this week’s session, We will be discussing different types of algorithms, like:
• Graphs
  
  • Types of graphs
  • Breadth-first search, depth-first search
  • Topological sort
  • Shortest path problem
• Algorithms
  
  • Dijkstra’s algorithm
  • Bellman–Ford algorithm
    
    • Minimum spanning tree problem
    • Prim’s algorithm
  • Kruskal’s algorithm

• In this week, we will discuss about 
  • Sorting- 
    
    • Types of sorting techniques
      
      • Bubble sort
      • Insertion sort
      • Selection sort
      • Quick sort
      • Merge sort
      • Heap sort
      • Count sort
      • Bucket sort
      • Radix sort
      • Shell sort

Searching is probably one of the most common actions performed in a regular business application. This involves fetching data stored in data structures like arrays, lists, and maps. Hashing is the process of converting a given key into another value. A hash function is used to generate the new value according to a mathematical algorithm.

• During this week we will be discussing the following:
  
  • Searching
    
    • Linear search
      
    • Binary search
      
  • Hashing
    
    • Hash function
      
    • Collision handling
      
  • Chaining
    
  • Open addressing
    
    • Linear probing, primary clustering
      
    • Quadratic probing, secondary clustering
      
  • Double hashing

A greedy algorithm is a simple, intuitive algorithm that is used in optimization problems.

• The topics discussed in this session will be-
  
  • The strategy of greedy algorithms
  • Elements of greedy algorithms
  • Advantages of greedy algorithms
  • Disadvantages of greedy algorithms
  • Applications of greedy algorithms
  • Knapsack problem
  • Job sequencing with deadlines
  • Huffman coding

The divide and conquer approach is pretty straightforward, the problem at hand is divided into smaller subproblems and then each problem is solved independently. As we keep dividing the subproblems into even smaller problems, we eventually reach a stage where no more division is possible.

• In the session this week, we will discuss:
  
  • The strategy of divide and conquer techniques
  • Advantages of divide and conquer techniques
  • Disadvantages of divide and conquer techniques
  • The master theorem of divide and conquer techniques
  • Applications of divide and conquer techniques
  • Find the median of two sorted arrays
     

Backtracking is an algorithmic-technique for solving problems recursively by trying to build a solution incrementally.

• We’ll discuss two methods used to backtrack.
  Backtracking- 
  
  • Brute force approach
  • N queens problem
• After backtracking, we will be studying how Java 8 collections framework is implemented. We will be covering the following,
  
  • Set
  • List
  • Queue
  • PriorityQueue
  • Map
  • HashSet
  • TreeSet
  • ArrayList
  • LinkedList
  • Vector
  • Dictionary
  • Stack

Dynamic Programming is also an algorithmic technique for solving optimization of problems. It is done by breaking the problem down into simpler subproblems, and utilizing the fact that the optimal solution to the overall problem depends upon the optimal solution to its subproblems.

• During this session, we will be covering the following:
  
  • Dynamic programming-
    
    • The strategy of dynamic programming
    • Properties of dynamic programming
    • Approaches of dynamic programming
    • 0/1 knapsack
    • Travelling salesman problem
    • Floyd Warshall
  • In the end, we will conclude and summarize the course by having a brief discussion on
    • Greedy vs Divide & Conquer vs Dynamic
    • Programming examples 

• Data types and operators
• Conditional statements
• Iterative statements
• Other control statements
• Functions and methods
• Working with Arrays in Java
• Working with Strings in Java

• Classes and objects
• Constructors
• The ‘this’ pointer
• The static and final keyword
• Access modifiers

• Inheritance (is-a relationship)
• Composition (has-a relationship)
• Abstract classes and interfaces
• Method overloading and overriding
• Polymorphism
• Encapsulation and abstraction

• Packages
• Exception Handling
• File handling
• I/O

• Optionals
• Memory Management
• Multithreading

• Database design
• ER model
• Entity and attributes
• Entity relationships
• Cardinality ratio
• Generalization, specialization, and aggregation
• Case study of Ecommerce website

• RDBMS
• Converting ER diagram to table
• Properties of relational model
• Primary key and foreign key
• Relational model
• E-commerce use case
• Codd’s rules
• Data integrity in RDBMS

• Database design
• Redundancy
• Insertion anomaly
• Functional dependencies
• Closure set of attributes
• Lossy decomposition
• Dependency preserving
• Normalization
• Transitive dependency
• 3NF
• BCNF
• Multivalued dependency
• 5NF
• Comparison between Normal forms, OLTP, and OLAP

• Discrete maths
• Relational Algebra and null values
• Relational calculus
• Characteristics of SQL
• Create a DB (example)
• SQL Constraints
• Foreign key
• SQL SELECT statement
• INSERT, DELETE statements
• Scalar and Aggregate functions
• HAVING clause
• SQL Aliases
• IN, BETWEEN operators
• EXISTS, ANY, ALL operator
• Auto increment
• MySQL best practices

• JOIN-types
• JOIN examples
• String operators
• Compound queries
• SQL index
• SQL views
• Query optimization
• Security Risks

• Introduction to NoSQL
• ACID
• Key value pair-based databases
• Search DB and Graph DB
• Advantages of NoSQL
• Introduction to MongoDB

• Working with MongoDB
• CRUD Operations with examples
• Data Modelling in NoSQL
• One to One and One to Many relationships
• Advanced MongoDB queries
  • Join, sort, group, and index

• In memory DB
• Redis
• Key value store
• Cashing layer
• Datatypes
• Transaction
• Backup of data from Redis

• PL/SQL Basics
• Operators
• Record
• Recursive Functions
• Exception Handling
• Triggers

• Transactions
• Concurrency control
• Isolation
• Consistency
• ACID
• Database lock
• Database lock types
• Lock Contention
• Deadlock
• Scaling the database
• Storage systems
• Database indexing
• Index types
• Distributed DB
• DB Replication
• Database sharding
• DB on Cloud