Cloud Foundry CLI Commands

Posted on by

Cloud Foundry Command Line Interface (cf CLI) is your primary tool for deploying and managing your applications and tasks.

Following are the Steps in Deploying Pivotal App

  1. Clone the App 
    git clone https://github.com/cloudfoundry-samples/cf-sample-app-rails.git
  2. Log in and Target the API Endpoint

    cf login -a YOUR-API-ENDPOINT
  3. Create a Service Instance

    cf create-service SERVICE_NAME
  4. Creating a Route
    Before deploying an app we need a route(API url) which tells where the app would be deployed.Now when creating a route, you need a route which may or may not available. You can opt for random route as below if the route is not available during time of push

    Custom Route

    cf create-route SPACE_NAME DOMAIN_NAME DESIRED_ROUTE_NAME 
cf create-route cloudnative cfapps.io pal-tracker.cfapps.io

    Random Route

    cf push APP_NAME -p APP_LOCATION/APP_NAME.jar --random-route
  5. Deploy the App 
    cf push APP_NAME
  6. Bind the Service Instance 
     cf bind-service APP_NAME SERVICE_NAME
  7. Verify the App – by browsing URL 
     
APP_NAME.cfapps.io
  8. A droplet is an archive within Cloud Foundry that contains the application ready to run on Diego. A droplet is the result of the application staging process.

    cf restage APP_NAME
  9. Use cf restage to refresh the environment variables and cf services to get the list of services
    Viewing Recent Logs in CLI

    cf logs APP_NAME --recent
  10. Viewing List of Environment Variables Available

    cf env APP_NAME
  11. Set environment from Command Prompt
    In the below example welcome.message is a variable created by user in gradle.build to be available at environment level.You can override it by supplying value in command prompt

    cf set-env APP_NAME ENV_VAR_NAME ENV_VAR_VALUE
cf set-env pal-tracker welcome.message "Hi There"
  12. Unset environment from Command Prompt

    cf unset-env APP_NAME ENV_VAR_NAME
  13. Viewing app info 
    cf app APP_NAME
  14. Scaling app – Vertical Scaling app instance has more memory or disk space
    -m allows to set memory space for app
    -f forces the app to restart

    cf scale APP_NAME -m 768Mb -f
  15. Scaling app – Horizontal Scaling more app instances serving requests
    Allows to set no of Instances

    cf scale APP_NAME -i 2

Mob Programming

Posted on by

Everything you want to know about Mob Programming

What is Mob Programming?
“All the brilliant people working on the same thing, at the same time, in the same space, on the same computer.” – Woody Zuill
“Mob Programming is continuous integration for ideas.” – Joshua Kerievsky
There are many ways to successfully mob. In general, there is one computer, a keyboard and mouse, one or more monitors, a whiteboard, one Driver and one or more Navigators sharing a work environment like the one below:

Ideal Mob Size The whole team, although teams of 3-6 people is ideal. Beyond 6 people, a Mob may have difficulties keeping everyone engaged. You can counter this with quicker rotation times.

Driver’s Role – The Driver operates the computer to input/implement ideas made by the Navigator(s).

Navigator(s) Role – Navigators direct the Driver. Usually it works to allow everyone in the Mob to interact directly with the Driver. If that causes too much chaos, have one Navigator give directions to the Driver and the Navigator serves as the voice of the Mob. Newbies to mobbing can ask for help on how to navigate.

Driver Dos & Don’ts

  1. Drivers don’t navigate. If the Driver is the only one who knows what to do, they can relinquish their role as Driver to the next person in the rotation.
  2. Each Driver can share how they prefer to be directed, including asking questions about intent, location and details. Ultimately, navigators must communicate in a way that allows the Driver to understand and take action.
  3. If no one is navigating, the Driver must stop typing.

Navigator(s) Dos & Don’ts

  1. Navigator ideas can only be programming by going through the Driver’s hands.
  2. Navigators must pay attention to the Driver’s skill level. If the Driver needs word-by-word instructions, the Mob must explain in detail what the Driver needs to do. If the Driver is more advanced, Navigators give higher-level instructions, like “commit it” or “move that method to the parent class”. Over-navigating entails too much direction, under-navigating too little.
  3. Don’t sit and watch the Driver work. Everyone learns and contributes in a productive Mob.

Mob Responsibilities

  1. Treat everyone with kindness, consideration, and respect
  2. Plan, discuss, research, and work out ideas on the whiteboard
  3. If a Driver begins to navigate and drive simultaneously, someone else in the Mob can call them out on it.
  4. Keep the Mob going as people join or leave
  5. Stakeholders, Managers, Subject Matter Experts, etc. are welcome to join a Mob, but are not required to drive or navigate.

Leaving/Joining the Mob – It is fine for someone to leave or join the Mob for whatever reason. If they are a Driver, they relinquish that role to the next person in line. The person leaving should tell the team when or if they’ll return so that the team can adjust the rotation schedule.

Switching Drivers – The Driver switch over shouldn’t take more than a few seconds. The teams should determine the best way to accomplish that goal. Switching Drivers is easiest when the Mob shares a single station and settings. If individuals in the Mob have their own preferred tools and settings, consider switching machines using a hardware HDMI switch, or use a system like WebEx or Zoom.

Physical Space – Here are some suggestions for the physical space and equipment setup:

  1. At least one large screen (big enough so that people can easily read code at a distance) is necessary. Some teams use two or more screens. Projectors can work, but are less desirable.
  2. Consider using wireless keyboards and mice to make it easier to switch Drivers.
  3. Mobbing can be noisy. Ideally, the team is in a room with a door that closes or is somewhat apart from other’s work areas. Conference rooms are usually suboptimal. They are designed for people to sit around a table and talk, not to program. You need to face the screen (without turning your head) as you work, and it’s best if participants can sit side by side to facilitate discussions.
  4. You need chairs or couches that are comfortable for longer than an hour.
  5. You need a large whiteboard and plenty of sticky notes.

Mob Timing and Breaks

  1. Use an automated timer (e.g., Dillon Kearns’ Mobster App) to initiate role changes and breaks.
  2. Switch roles every 7 minutes on average (beginners should switch every 2-4 minutes).
  3. The whole Mob should take regularly scheduled breaks. The pomodoro method, a proven method of taking regular breaks to increase efficiency, suggests taking breaks every 48 minutes.

Bias for Action – When discussing how to solve a problem, get out of the abstract as soon as possible.

  1. Do not argue for more than 10 minutes.
  2. If there are 2 ideas, try both, then decide which the Mob likes better.
  3. Keep the Mob moving with this quote from Brian Marick: “An example would be handy right about now”.

The Value of Mobbing – When done well, mobbing helps a team:

  1. Deliver solutions faster by increasing focus, building skills and sharing knowledge.
  2. Produce better quality code because the entire team reviews the code as it is being written.
  3. Feel the pain of tedious tasks. This is good, as it biases you toward fool-proofing and automation.
  4. Cross train it’s members and remove knowledge silos by learning together.
  5. Deliver results faster by reducing the team’s “work in progress” and by eliminating delays from handoffs with the whole team present.

Mobbing Pitfalls – A poorly functioning Mob will produce value slowly. The following are some signs of poor mobbing and what do to if you observe these behaviors:

  1. Excessive discussion or arguing – Run some experiments, then decide which the Mob likes better.
  2. Zoning out – Take a break from the Mob
  3. Ignoring Mob roles/timers – Team members should hold each other accountable
  4. Producing poor designs or not valuing good design – A Mob that lacks people with good design skills won’t magically produce good designs. To improve the design, the Mob should get expert help.
  5. Conflict between team members – In order to be a well-functioning Mob, everyone must be treated with kindness, consideration, and respect.

Don’t Stop the Mob – The Mob can temporarily delegate a member as a researcher, to find solutions to something they cannot easily figure out. Meanwhile, the Mob can work elsewhere in the code. It is important that people feel comfortable enough to ask questions, but if the Mob is moving slowly due to a lot of questions, it is better to set aside some time outside of the Mob for someone to have questions answered. Fast throughput is an important goal.

Invite Experts – If a Mob gets stuck, they may invite an expert to join them to help resolve a problem. Be sure it is an invitation and not a demand (they are not required to drive).

Holland Trip 1

Posted on by

Holland Trip 1
Learnt from Own Mistakes

  1. Don’t buy SIM Card without receipt and Proper Investigation on Plans at Airports
  2. Keep Track of Expenses and Bill amount since saving small amount may make big change in native currency
  3. Prefer Flight which offers more baggage space. Ethiad over Emirates
  4. When staying at Hotels always ask for Emergency Contact no at reception incase of unforeseen circumstances
  5. While Taking Monthly Pass or Weekly Pass, do R&D before applying to get the Best Plan
  6. Things Missed – Net Bag to put Old Cloths, Vadagam, Tea Powder, Coriander Powder, Garam Masala, Spices, Apalam, Detergent, Dish wash liquid
  7. Things likely to have more – Dal Power, Thoor Dal(Atleast 2 kg), Socks(Atleast 4 pairs), Cooker Belt
  8. Things likely to have less – Turmeric Powder, Sambar Powder, Rasam Powder
  9. If possible carry Tiffin Box with Thermal Insulation, Small vessel to boil milk and Small Mixer
  10. Come up with a ball park figure of total before going to counter – Albert Heijn Chocolate Exp
  11. Start Cooking before two weeks from start date of onsite
  12. If you have too much of weight and not sure whether the baggage would incur more charges during checkin, keep extra space in hand baggage since they are mostly not weighed and things from overweight baggage can me moved to hand baggage. 32 Kg of weight where 2 kg could be charged could be moved to hand baggage incase there is only 5 Kg worth of things added to it
  13. Things you buy in duty free are not weighed
  14. Carry Long wallet from Infy in order to avoid tearing of Bills

Learnt from Other’s Mistakes

  1. Never opt for room with 6 people rather go for people with 4 people. Always get mail confirmation for changes in bill amount without fail. Maintain all bills in a pouch
  2. Dont speak native language with some words in language others speak. Even if you do so dont laugh since you may end up in different understanding(Swiss Incident while stainding for Bus)
  3. Dressing Cloth in case you have suffered cuts while cutting vegetable

Learnt from Others

  1. Smiling at Others, Greeting People and Saying Thank you at end of receiving service
  2. Patience in Road and letting others
  3. Time Keep up from NLD Transport
  4. Have Secondary Wallet with Anonymous Card and Money with Friends contact no. Incase the primary goes missing you wont end up helpless.
  5. Pappu and Moore Kuzhambu

Skipping Tests across Multiple Child Modules in Maven

Posted on by

There would be scenarios where you need to skip few modules when building parent project because the unit test fail in child project. In such scenario we should define the surefire plugin at parent pom.xml and include and exclude the child modules for which the unit test should be executed.

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.4.2</version>
        <configuration>
          <skipTests>true</skipTests>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

Rather than defining plugin(in our case surefire plugin), we can create a profile and define the behavior of plugins within the profile.

<project>
  [...]
  <profiles>
    <profile>
      <id>noTest</id>
      <activation>
        <property>
          <name>noTest</name>
          <value>true</value>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.4.2</version>
            <configuration>
              <skipTests>true</skipTests>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
  [...]
</project>

Now lets include and exclude child modules for which unit test should be carried out

Including Unit Test
Only the following(ChildModule3.java) file would be included and others would be excluded

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.0.0-M4</version>
        <configuration>
          <includes>
            <include>ChildModule3.java</include>
          </includes>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

Excluding Unit Test
Only the following(ChildModule1.java, ChildModule2.java) file would be excluded

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.0.0-M4</version>
        <configuration>
          <excludes>
            <exclude>**/ChildModule1.java</exclude>
            <exclude>**/ChildModule2.java</exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

How to activate profile in command prompt

>>mvn clean install -PnoTest

How to see list of active Profiles

>>mvn help:active-profiles

If you want to know what version of an specific plugin you have installed you can do this:

mvn -Dplugin=org.codehaus.mojo:wagon-maven-plugin help:describe
mvn -Dplugin=groupId:artifactId help:describe
mvn help:effective-pom

How to execute life cycle task using specific plugin

>>mvn groupID:artifactID:version:goal
>>mvn org.apache.maven.plugins:maven-checkstyle-plugin:2.5:checkstyle

Gradle Basics

Posted on by
  1. Gradle is Partly Declarative and Partly Programmatic and Uses Domain Specific Language(DSL) coded in groovy or kotlin in build.gradle
  2. Gradle Parses build.gradle file and constructs DAG(Directed Acyclic Graph) and constructs a graph of task
  3. Gradle executes tasks in order.If ouput of task is same as last output, then task wont be executed
  4. Gradle manages trasitive dependency on its own(Similar to maven) and gradle uses repositories.
  5. Gradle updates to new version of Dependencies

Teardown of build.gradle file

  1. To make gradle, java aware we need to add apply plugin:’java’
  2. Once the above line is added, the following tasks get tagged to project – clean, assemble, compile, test
  3. dependencies and repositories are added in flower bracket like one below
  4. under dependencies we can have multiple tasks. In the below code compile is added as a task

build.gradle

group 'com.mugil.employeeManagement'
version '1.0-Snapshot'

apply plugin: 'java'

sourceCompatibility=1.8

repositories {    
    mavenCentral()
}

dependencies {
	compile 'com.google.code.gson:gson:2.8.4'
}

What is the Difference between gradlew and gradle?

gradlew is a wrapper(w – character) that uses gradle.

Under the hood gradlew performs three main things:

  1. Download and install the correct gradle version
  2. Parse the arguments
  3. Call a gradle task

Using Gradle Wrapper we can distribute/share a project to everybody to use the same version and Gradle’s functionality(compile, build, install…) even if it has not been installed.

To create a wrapper run:

gradle wrapper

This command generate:

gradle-wrapper.properties will contain the information about the Gradle distribution

How to skip Gradle Test?

gradle build -x test

How to supply Argument to Spring Controller during application startup in Gradle Wrapper 

gradlew bootRun --args='--welcome.message=Mugil'

WelcomeController.java
In the below code welcomeMsg variable is assigned value during application startup. In similar ways environment variables could be setup
by supplying arguments as parameters while executing gradlew bootrun 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WelcomeController {
    public String welcomeMsg;

    @Autowired
    public WelcomeController(@Value("${welcome.message}") String message) {
        welcomeMsg = message;
        System.out.println("Hi "+ message);
    }

    @GetMapping("/")
    public String sayHello() {
        return "Mugil";
    }
}

Logarithm Basics

Posted on by

Logarithmic and Exponential Form
Any number can be written in Logarithmic and Exponential Form

Logarithmic Form
logbx = a

Exponential Form
x = ba

Logarithmic Function and Exponential function are inverse function to each other
A function which is written in exponential form can be written into logarithmic form given both have the same base.

y = log3x

is equivalent to

3y = x

Let take a number 34

34 = 3 x 3 x 3 x 3 = 81

log381 = 4

Here
3 is Base
4 is exponent

What is the exponent of the below statement? What is the value of x?

log5125 = x
5 x 5 x 5 = 125
x = 3

log41 = x
x = 0

Why Know Logarithms?
Let us take the set of below numbers

1
10
1000
100000(105)
100000000(108)
100000000000000(1014 )

When we try to plot the numbers we won’t be able to accommodate the small and the higher values since the variations are huge and the difference between the first and last number is huge. In such a case, we can represent the numbers in terms of logarithms with respect to some other decimal value. Now the above numbers could be written as below.

log101 = 0
log101 = 1
log101000 = 3
log10x = 5
log10x = 8
log10x = 14

Now it is easy to accommodate 0,1,3,5,8,14 in the graph.

Practical application of Logarithms?
The best practical usage of the logarithm is the Richter scale which is used to measure the earthquake. Richter scale is a logarithmic scale with base 10. Let’s say we there are earthquakes in 3 locations as below
India – 6.0
Thailand – 7.0
Japan – 9.0

Now the difference of intensity between the earthquake in India and Thailand is 10 Times Stronger
The difference of intensity between the earthquake in India and Japan is 1000 Times Stronger

Fundamental properties

1st Property
logbx = a
x = ba
logbx = ba

2nd Property
logbb = x
logbx = b
x = 1

log44 = 1
log2525 = 1

3rd Property
logbbn = x
bx = bn
x = n

log11113 = 3
log445 = 5

  1. logbx = ba
  2. logbb = 1
  3. logbbn = n

Condition

  • logba – the value of a(argument) should be greater than 0 – Incorrect
  • logb0 is undefined and logb(-ve no) is incorrect – Incorrect
  • logb1= 0 is correct
  • logb(1/2)= -1 is correct
  • log1a is incorrect- base cannot be 1
  • log(-ve)a is incorrect- base cannot be -ve number

    • Change of Base Rule

  • logba = logxa/logxb where x>0, x != 1 and a,b >0

    • log denotes log to the base 10 and ln or log e represents natural log.

    e – Maximum possible result after continuously compounding 100% growth over a time period

    logab x logba = 1

    Logarithm Rules

    1. logb(xy)= logbx + logby
    2. logb(x/y)= logbx – logby
    3. logban = nlogba

    Time Complexity of Data structures

    Posted on by

    What is Asymptotic Analysis
    Asymptotic Analysis, we evaluate the performance of an algorithm in terms of input size (we don’t measure the actual running time). We calculate, how does the time (or space) taken by an algorithm increases with the input size.

    Asymptotic Analysis is not perfect, but that’s the best way available for analyzing algorithms. For example, say there are two sorting algorithms that take 1000nLogn and 2nLogn time respectively on a machine. Both of these algorithms are asymptotically same (order of growth is nLogn). So, With Asymptotic Analysis, we can’t judge which one is better as we ignore constants in Asymptotic Analysis. Also, in Asymptotic analysis, we always talk about input sizes larger than a constant value. It might be possible that those large inputs are never given to your software and an algorithm which is asymptotically slower, always performs better for your particular situation. So, you may end up choosing an algorithm that is Asymptotically slower but faster for your software.

    Increasing Order of Growth

    Time Complexity Name Example
    1 Constant Adding Element to the Front oif Linked List
    logn Logarithmic Finding the element in the Sorted Array
    n Linear Finding an element in an unserted Array
    nLogn Linear Logarithmic Sorting n items by divide and conquer technique
    n² Quadriatic Shortest Path between two nodes in a graph
    n³ Cubic Matrix Multiplication
    2n Exponential The Towers of Hanoi Problem

    Let’s take a simple java code which looks for a number in an array

    public class LinearSearch
{  
    // Linearly search x in arr[].  If x is present then return the index, 
    static int search(int arr[], int n, int x) { 
        int i; 
        for (i = 0; i < n; i++) { 
            if (arr[i] == x) { 
                return i; 
            } 
        } 
        return -1; 
    }   

    public static void main(String[] args) 
    { 
        int arr[] = {41, 10, 40, 15}; 
        int x = 40; 
        int n = arr.length; 
        System.out.printf("%d is present at index %d", x, search(arr, n, x)); 
  
    } 
}

    In the above scenario we have
    Worst Case – O Notation(Big O Notation) – In the Worst case we calculate the Upper bound of the algorithm with the worst possible input. In our case it is O(n) if the element is found as last item of the array. The Big O notation defines an upper bound of an algorithm, it bounds a function only from above. For example, consider the case of Insertion Sort. It takes linear time in the best case and quadratic time in the worst case. We can safely say that the time complexity of Insertion sort is O(n^2)

    Best Case – Ω Notation(Omega Notation) – In the Best case we calculate the lower bound of the algorithm with the best possible input. In our case it is O(1) if the element is found in as first item of the array.

    AverageCase- Θ Notation(Theta Notation) – average case analysis, we take all possible inputs and calculate computing time for all of the inputs. Sum all the calculated values and divide the sum by total number of inputs

    1. A case is a class of inputs for which you consider your algorithm’s performance.
    2. the best case is the input that minimizes the function and the worst case is the input that maximizes the function
    3. An algorithm always have worst case, best case and average case
    4. Each case again has an upper bound, lower bound.Bounds are functions that we use to compare against a given algorithm’s function.
    5. An upper bound is a function that sits on top of another function. A lower bound is a function that sits under the other function. When we talk about Big O and Big Omega, we don’t care if the bounds are ALWAYS above or below the other function
    6. When we talk about worst case we would be always interested in upper bound and when we talk about Best Case we are always interested in lower bound.Because of this Worst Case and upper bound are used interchangably and vice versa.
    7. Worst Case Upper Bound: We are often interested in finding a tight upper bound on the worst case, because then we know how poorly our algorithm can run in the worst of times. Insertion sort’s worst case is a list that is completely out of order (i.e. completely reversed from its correct order). Every time we see a new item, we have to move it to the start of the list, pushing all subsequent items forward (which is a linear time operation, and doing it a linear number of times leads to quadratic behavior). However, we still know that this insertion behavior will be O(n2) in the worst case, acting as a tight upper bound for the worst case.
    8. Best Case Lower Bound: Insertion Sort works by walking through the list, and inserting any out-of-order it comes across in the right place. If the list is sorted, it will only need to walk through the list once without doing any inserts. This means that the tightest lower bound of the best case is Ω(n). You cannot do better than that without sacrificing correctness, because you still need to be able to walk through the list (linear time). However, the lower bound for the best case is better than the lower bound for the worst case!
    9. Worst Case Lower Bound: The classic example here is comparison-based sorting, which is famously known to be Ω(n log(n)) in the worst case. No matter what algorithm you devise, I can pick a set of worst-case inputs whereby the tightest lower bound function is log-linear. You cannot make an algorithm that beats that bound for the worst case, and you shouldn’t bother trying. It’s the basement of sorting. Of course, there are many lower bounds for the worst case: constant, linear, and sublinear are all lower bounds. But they are not useful lower bounds, because there the log-linear lower bound is the tightest one.
    10. Best Case Upper Bound: What’s the worst our algorithm can do in the best of times? In example before of finding an element in a list, where the first element was our desired element, the upper bound is O(1). In the worst case it was linear, but in the best case, the worst that can happen is that it’s still constant. This particular idea isn’t usually as important as Worst Case Upper Bound, in my opinion, because we’re usually more concerned with dealing with the worst case, not the best case.

    Legends

    Time Complexity

    Node Package Manager

    Posted on by
    1. Node Package manager is a package manager which ships along node
    2. It is a Javascript package manager which helps to manage modules like HTTP, Event etc..
    3. Once the npm init is run package.json would be created in the project folder.It is similar to pom.xml for Maven project which saves all the settings and dependencies
    4. To check the npm version 
      >>npm -v 
>>npm --version
    5. To create a new project we use the below command – take default setting by telling -yes 
      >>npm init -yes
    6. To Install a new package is as below 
      >>npm install NAME_OF_PACKAGE
    7. To Set particular config name 
      >>npm set CONFIG_KEY CONFIG_VALUE
>>npm set init-licencse "MIT"
    8. To Get particular config name 
      >>npm get CONFIG_KEY 
>>npm get init-licencse
    9. To Install a new package 
      >>npm install packagename
>>npm install loadash

      Running the above command is going to create a node_modules folder in project with the dependencies for the package(loadash) installed.

    10. To Install only dependencies that are needed to run app other than utility dependencies like gulp which provides minified version of JS use below command 
      >>npm install --production
    11. To remove dependencies 
      >>npm remove gulp
    12. To install specific version 
      >>npm install gulp@4.7.3
    13. To update latest version 
      >>npm update gulp
    14. Semantic versioning formart.PatchVersion includes bug fixes and minor tweaks 
      MajorVersion.MinorVersion.PatchVersion
4.7.8
    15. How to find the location of node modules 
      >>npm root -g

      This will take you to location C:\Users\Mugil\AppData\Roaming\npm\node_modules

    16. How to install server globally – live-server will reload the JS files without restart of server 
      >>npm install -g live-server

      This will take you to location C:\Users\Mugil\AppData\Roaming\npm\node_modules

    17. When you move the project to new environment no need to move the node_modules folder similar to avoiding JAR while shifting java application.We just need to move the JS file and package.json which contains the details of dependencies. Running npm install will read the package.json file and load the dependencies in new environment

    package.json

       "name": "my_package",
    "description": "",
    "version": "1.0.0",
    "main": "index.js",
    "scripts": {
      "test": "echo \"Error: no test specified\" && exit 1"
    },
    "dependencies": {"loadash" : 14.7.8},
    "keywords": [],
    "author": "",
    "license": "ISC",
    "bugs": {
      "url": "https://github.com/ashleygwilliams/my_package/issues"
    },
    "homepage": "https://github.com/ashleygwilliams/my_package"
  }

    How to run some js file in the beginning of the server
    I have JS server which needs to start at the beginning of application. In such case I would be defining the JS file in scripts.
    You need to call npm start after chaning package.json file
    package.json

    .
.
"scripts": {
      "start": "node server.js"
    }
.
.

    Let’s create a simple application which greets with Welcome message in console on start
    package.json

    {
  "name": "school",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "Mugil",
  "license": "ISC"
}

    index.js

    console.log('Welcome to School .....');

    output

    Welcome to School .....

    package.json
    live-server allows you to run code without restarting server after changes.

    .
.
"scripts": {
    "start": "node index.js",
    "server": "live-server"
  }
.
.

    >>npm run server

    Observable and Observer

    Posted on by
    1. Obersvable and Observer are from RxJS similiar to Event and Event listener
    2. Observer can listen to three actions of observable that is next, error and complete
    3. Below we create a observer JSON key value pair and calling function based on the action from observable
    4. We need to subscribe to Observable in ourcase observable and pass observer as parameter
    5. We should unsubscribe to obeservable once we are done inorder to prevent memory leaks

    test.html

    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.4.0/Rx.js"></script>

    <script>
        var observer = {
            next: function (value) { console.log(value); },
            error: function (error) { console.log(error); },
            complete: function () { console.log("Completed..!") }
        };


        const observable = new Rx.Observable(obs => {
            obs.next(102);
            obs.next(103);
            setTimeout(function () {
                obs.next(109);
                obs.complete("Completed");
            }, 2000);
        });

        observable.subscribe(observer);
    </script>

    Observable over Stream
    Observable is similar to event which keeps happening. During its occurance it could emit values, throw error or comes to complete.

    setTimeout and setInterval

    Posted on by

    setTimeout is the functionality which comes along with the webapi whereas setInterval is javascript implementation.

    setTimeout(expression, timeout); runs the code/function once after the timeout.
    The clearTimeout() method stops the execution of the function specified in setTimeout().

    function doStuff() {
alert("run your code here when time interval is reached");
}
var myTimer = setTimeout(doStuff, 5000);

    Output

    run your code here when time interval is reached

    setInterval(expression, timeout); runs the code/function in intervals, with the length of the timeout between them.

    function doStuff() {
alert("run your code here when time interval is reached");
}
var myTimer = setInterval(doStuff, 5000);

    Output

    run your code here when time interval is reached