admin « CodeThatAint

Used to perform a release of a project with Maven.

Key goals in mvn release Plugin

release:clean Clean up after a release preparation.
release:prepare Prepare for a release in SCM(Source Code Management i.e. nexus).
release:rollback Rollback a previous release.
release:perform Perform a release from SCM.

Prerequisite
Since this plugin releases artifacts(could be JAR’s, ZIP’s WAR’s or TAR’s) into the repository we need to make sure
credentials are properly configured in settings.xml in the conf folder, Maven installation directory. Failing to do so would
end up in authorization error while running the goals in the plugin

Syntax

>>mvn release:clean release:prepare
>>mvn release:perform

How it Works

Once you run release:clean it would clean the old class files just like maven clean
When you run release:prepare it would read the pom.xml in the project. If you don’t have snapshot version defined you would end up with snapshot not found error since the
plugin assumes snapshot is the one which needs to be released.
Now on running release:prepare will ask for the name of the version and will change the line snapshot in pom.xml. It also does a git push of pom.xml in the remote repo
When you run release:perform it will push the jar in the nexus repo so it would be available for other teams.
When you are working on App-Model-0.0.1-SNAPHSOT using mvn:prepare and mvn:perform would put App-Model-0.0.1 in repo at the same time modifying pom.xml in local and git to 0.0.2-SNAPSHOT. So the dependent project needs to be updated likewise

Other know issues:
Sometime the release:perform fails because it complains tag already exists in repo. In such a case, you need to delete the tags and perform release again.
During the release, the list of files that needs to go along release would be tagged to particular version. In some cases, there would be files with the same tag name. In such case, maven-plugin complains the tag already exists.

To get the recent Tag

//Recent Tags
git describe --tags

//Latest Tags - With --abbrev=0 it should return closest annotated tag
git describe --abbrev=0

To delete the tag
git fetch is needed to get the remote tags to be displayed in local, kind of refresh

 
//To delete tag locally
git tag -d TAG_NAME  

git fetch

//To delete tag remote
git push --delete origin TAG_NAME

To get the Latest tags for different commits done across various branches

 
git describe --tags $(git rev-list --tags --max-count=1)

Why CLOUD?
SCALABILITY – The advantage of cloud is you can setup servers on demand and pay only for usage. SCALABILITY
INSTANT – Quick fix like plugins instead of long time for configuring hosting servers
MONEY – Pay for what you use.

What is SaaS, PaaS and IaaS? With examples
IAAS (Infrastructure As A Service) :
The base layer
Deals with Virtual Machines, Storage (Hard Disks), Servers, Network, Load Balancers etc
IaaS (Infrastructure as a Service), as the name suggests, provides you the computing infrastructure, physical or (quite often) virtual machines and other resources like virtual-machine disk image library, block and file-based storage, firewalls, load balancers, IP addresses, virtual local area networks etc.

Examples: Amazon EC2, Windows Azure, Rackspace, Google Compute Engine.

PAAS (Platform As A Service) :
A layer on top on PAAS
Runtimes (like java runtimes), Databases (like mySql, Oracle), Web Servers (tomcat etc)
PaaS (Platform as a Service), as the name suggests, provides you computing platforms which typically includes operating system, programming language execution environment, database, web server etc.

Examples: AWS Elastic Beanstalk, Windows Azure, Heroku, Force.com, Google App Engine, Apache Stratos.

SAAS (Software As A Service) :
A layer on top on PAAS
Applications like email (Gmail, Yahoo mail etc), Social Networking sites (Facebook etc)
While in SaaS (Software as a Service) model you are provided with access to application software often referred to as “on-demand software”. You don’t have to worry about the installation, setup and running of the application. Service provider will do that for you. You just have to pay and use it through some client.

Examples: Google Apps, Microsoft Office 365.

Pizza as a Service
null

IAAS vs SAAS vs PAAS
null

Traditional vs CloudNative Applications
TRADITIONAL APPLICATION uses sticky servers which sticks to one User – one Server. If the server goes down then transition from one to another removes the user session in the first server.

CLOUD NATIVE APPLICATION are non sticky servers.The server maintains a shared state by many ways like using
backend database or usings session stores.

What is SERVERLESS?
SERVERLESS doesnot mean no server, rather you would be using someones server.Cloud is serverless.

‘Serverless’, like many things in our space, is becoming an overloaded term.. but generally what it means is “Functionally, Our architecture does not depend on the provisioning or ongoing maintenance of a server”

The first instance that comes to mind is a single page javascript app, that uses local storage, and is stored on something like Amazon S# or Github Pages (or any static site – those are just common examples). Imagine something like a ‘todo’ or ‘getting things done’-style application that runs entirely in your browser. Your browser hits a service like S3 to download the code, and the items you store are all stored in local storage in your browser. There is no server you maintain for this.

The second instance, and is a bit more complicated (and also the one that popularized the term ‘serverless’), uses a service like AWS Lambda. Let me explain this by presenting the problem it solves:

Many times in my career I’ve solved a business problem for a client with little more than some ruby code that performed a periodic extract, transform, and load (typically written as a rake task). Once solved, I’d typically automate it with cron. Then the problem becomes ‘where do I host this thing that runs once every hour?’ For some clients, we’d set up a server in their existing infrastructure. For others, we’d set up an EC2 instance, even though it was idle 99% of the time. In either of those circumstances, there is a server that requires provisioning, patching, monitoring, updating, etc.

With Amazon Lambda, I can take that rake task and run it on their service as a pure ‘function’. I can even schedule it. No longer would that client need a piece of infrastructure for such a simple once-an-hour thing.

With ‘serverless’ there is still a server, just like with ‘cloud’ there is still a computer. There is just a level of abstraction on top of it that takes some of the environmental responsibilities for you.

Azure vs AWS?
Azure: Azure users choose Virtual Hard Disk (VHD), which is equivalent to a Machine Instance, to create a VM. VHD can be pre-configured by Microsoft, the user or a third party. The user must specify the amount of cores and memory.

Storage AWS: AWS has temporary storage that is allocated once an instance is started and destroyed when the instance is terminated. They also provide block storage (same as hard disks), that can be separate or attached to an instance. Object storage is offered with S3; and data archiving services with Glacier. Fully supports relational and NoSQL databases and Big Data.

Support Plans AWS: Pricing is based on a sliding scale tied to monthly usage, so your bill could potentially be quite high if you’re a heavy user.

Azure: Users are billed a flat monthly rate.

There are 3 ways to supply argument to Cloud app

Command Line during app startup
using gradle.build
manifest.yml

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;
    }

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

How to supply Argument to Spring Controller using gradle.build
build.gradle

.
.
.
bootRun.environment([
        "WELCOME_MESSAGE": "A welcome message",
])

test.environment([
        "WELCOME_MESSAGE": "Hello from test"
])

supply Arguments using manifest.yml
(works only in cloud env since manifest.yml is way of supplying argument from app to cloud env)

---
applications:
  - name: pal-tracker
    path: build/libs/pal-tracker.jar
    random-route: true
    env:
      WELCOME_MESSAGE: Hello from Cloud Foundry
      JBP_CONFIG_OPEN_JDK_JRE: '{ jre: { version: 11.+ } }'

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

Clone the App

git clone https://github.com/cloudfoundry-samples/cf-sample-app-rails.git

Log in and Target the API Endpoint
```
cf login -a YOUR-API-ENDPOINT
```
Create a Service Instance
```
cf create-service SERVICE_NAME
```
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
```
Deploy the App
```
cf push APP_NAME
```
Bind the Service Instance
```
 cf bind-service APP_NAME SERVICE_NAME
```
Verify the App – by browsing URL
```
 
APP_NAME.cfapps.io
```
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
```
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
```
Viewing List of Environment Variables Available
```
cf env APP_NAME
```
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"
```
Unset environment from Command Prompt
```
cf unset-env APP_NAME ENV_VAR_NAME
```
Viewing app info
```
cf app APP_NAME
```
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
```
Scaling app – Horizontal Scaling more app instances serving requests
Allows to set no of Instances
```
cf scale APP_NAME -i 2
```

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

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.
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.
If no one is navigating, the Driver must stop typing.

Navigator(s) Dos & Don’ts

Navigator ideas can only be programming by going through the Driver’s hands.
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.
Don’t sit and watch the Driver work. Everyone learns and contributes in a productive Mob.

Mob Responsibilities

Treat everyone with kindness, consideration, and respect
Plan, discuss, research, and work out ideas on the whiteboard
If a Driver begins to navigate and drive simultaneously, someone else in the Mob can call them out on it.
Keep the Mob going as people join or leave
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:

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.
Consider using wireless keyboards and mice to make it easier to switch Drivers.
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.
You need chairs or couches that are comfortable for longer than an hour.
You need a large whiteboard and plenty of sticky notes.

Mob Timing and Breaks

Use an automated timer (e.g., Dillon Kearns’ Mobster App) to initiate role changes and breaks.
Switch roles every 7 minutes on average (beginners should switch every 2-4 minutes).
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.

Do not argue for more than 10 minutes.
If there are 2 ideas, try both, then decide which the Mob likes better.
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:

Deliver solutions faster by increasing focus, building skills and sharing knowledge.
Produce better quality code because the entire team reviews the code as it is being written.
Feel the pain of tedious tasks. This is good, as it biases you toward fool-proofing and automation.
Cross train it’s members and remove knowledge silos by learning together.
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:

Excessive discussion or arguing – Run some experiments, then decide which the Mob likes better.
Zoning out – Take a break from the Mob
Ignoring Mob roles/timers – Team members should hold each other accountable
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.
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
Learnt from Own Mistakes

Don’t buy SIM Card without receipt and Proper Investigation on Plans at Airports
Keep Track of Expenses and Bill amount since saving small amount may make big change in native currency
Prefer Flight which offers more baggage space. Ethiad over Emirates
When staying at Hotels always ask for Emergency Contact no at reception incase of unforeseen circumstances
While Taking Monthly Pass or Weekly Pass, do R&D before applying to get the Best Plan
Things Missed – Net Bag to put Old Cloths, Vadagam, Tea Powder, Coriander Powder, Garam Masala, Spices, Apalam, Detergent, Dish wash liquid
Things likely to have more – Dal Power, Thoor Dal(Atleast 2 kg), Socks(Atleast 4 pairs), Cooker Belt
Things likely to have less – Turmeric Powder, Sambar Powder, Rasam Powder
If possible carry Tiffin Box with Thermal Insulation, Small vessel to boil milk and Small Mixer
Come up with a ball park figure of total before going to counter – Albert Heijn Chocolate Exp
Start Cooking before two weeks from start date of onsite
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
Things you buy in duty free are not weighed
Carry Long wallet from Infy in order to avoid tearing of Bills

Learnt from Other’s Mistakes

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
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)
Dressing Cloth in case you have suffered cuts while cutting vegetable

Learnt from Others

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

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

Teardown of build.gradle file

To make gradle, java aware we need to add apply plugin:’java’
Once the above line is added, the following tasks get tagged to project – clean, assemble, compile, test
dependencies and repositories are added in flower bracket like one below
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:

Download and install the correct gradle version
Parse the arguments
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'

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";
    }
}

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

Logarithmic Form
log_bx = a

Exponential Form
x = b^a

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 = log₃x

is equivalent to

3^y = x

Let take a number 3⁴

3⁴ = 3 x 3 x 3 x 3 = 81

log₃81 = 4

Here
3 is Base
4 is exponent

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

log₅125 = x
5 x 5 x 5 = 125
x = 3

log₄1 = x
x = 0

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

1
10
1000
100000(10⁵)
100000000(10⁸)
100000000000000(10¹⁴ )

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.

log₁₀1 = 0
log₁₀1 = 1
log₁₀1000 = 3
log₁₀x = 5
log₁₀x = 8
log₁₀x = 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
log_bx = a
x = b^a
log_bx = b^a

2nd Property
log_bb = x
logb^x = b
x = 1

log4⁴ = 1
log25²⁵ = 1

3rd Property
log_bbⁿ = x
b^x = bⁿ
x = n

log₁₁11³ = 3
log₄4⁵ = 5

log_bx = b^a
log_bb = 1
log_bbⁿ = n

Condition

log_ba – the value of a(argument) should be greater than 0 – Incorrect

log_b0 is undefined and log_b(-ve no) is incorrect – Incorrect

log_b1= 0 is correct

log_b(1/2)= -1 is correct

log₁a is incorrect- base cannot be 1

log_(-ve)a is incorrect- base cannot be -ve number

Change of Base Rule

log_ba = log_xa/log_xb 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

log_ab x log_ba = 1

Logarithm Rules

log_b(xy)= log_bx + log_by
log_b(x/y)= log_bx – log_by
log_baⁿ = nlog_ba

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
2ⁿ	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

A case is a class of inputs for which you consider your algorithm’s performance.
the best case is the input that minimizes the function and the worst case is the input that maximizes the function
An algorithm always have worst case, best case and average case
Each case again has an upper bound, lower bound.Bounds are functions that we use to compare against a given algorithm’s function.
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
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.
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.
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!
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.
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.