Web Development

Design Phase:-
Below all these represent different stages of the UX/UI design flow:-

Wireframes represent a very basic & visual representation of the design.
It has very low fidelity (features) and is often created with black and white sketches.

Mockups are ‘pixel perfect’. It’s the exact graphical representation and presents all the content and functions. We call it high fidelity. Mockups aren’t just interactive and clickable.

Prototypes are closest to end product. It is clickable and interactive.
Usually, the team tests the prototype in earlier stages and saves a lot of costs.

Wireframes and mockups are static whereas the prototype is dynamic.

online wireframe tool https://wireframe.cc/

******************************************************************************
Development Phase:-
The developmental stage is the point where the web site itself is created. It's divided into 2 parts.
Front - end - 
This involves writing valid HTML / CSS / JS code and using libraries/frameworks like bootstrap, angular, react, jQuery that complies to current web standards, maximising functionality, as well as accessibility for as large an audience as possible.
Back - end -
This involves writing server end code which includes framework like spring/java OR django/python and sql database like oracle/mysql OR no-sql database like mongodb OR cache like redis.

******************************************************************************
Hosting Phase:-
Once you build your web site, it is time to upload the site. Some websites offer domain name registration and web hosting services as well, or have recommendations as to where you can host your site.
Once these accounts have been setup, and your web site uploaded to the server, the site should be put through one last run-through.

Other final details include plugin installation (CMS driven web sites and SEO (Search Engine Optimization). SEO is the optimization of your web site with elements such as title, description and keyword tags which help your web site achieve higher rankings in the search engines.

******************************************************************************
Maintenance Phase:-
It’s really up to you as far as how comfortable you feel with updating your own web site. Some people prefer to have all the control so that they can make updates to their own web site the minute they decide to do so. Others prefer to hand off the web site entirely, as they have enough tasks on-hand that are more important for them to handle directly.

A web site driven by a CMS gives you the ability to edit the content areas of the web site yourself. You are given access to a back-end administrative area, where you can use an online text editor (similar to a mini version of Microsoft Word). You’ll be able to edit existing content this way, or if you are feeling more adventurous, you can even add new pages and content yourself. The possibilities are endless!


Other maintenance type items include regular site backups, CMS upgrades, additional plugin installation, etc.

******************************************************************************
Website Layout:-
Most of the web pages in website are using common layout. For example layout which consists of header, footer and sidebar - are fixed for each page and the content which varies by the page.
Now, Logical idea is to try to extract and reuse common parts.

Let’s say we have a simple web app which has 5 different routes/pages (login, registration, dashboard, users, account settings) and two layouts.
One layout with content and footer, let’s call it layout 1, and layout 2 with header, footer, sidebar and content.

layout 1 = content + footer
layout 2 = header + sidebar + content + footer

Also let’s say that login and registration pages have layout 1, while others have layout 2.

Most of the web pages in website are using common layout. For example layout which consists of header, footer and sidebar - are fixed for each page and the content which varies by the page.
Now, Logical idea is to try to extract and reuse common parts.


Single Page Applications

******************************************************************************
Styling web application with CSS framework:-

$ npm install --save bootstrap //adding bootstrap

If its angular application, then open the angular.json file and add the file paths of Bootstrap CSS and JS files to the styles and scripts arrays under the build target:

"architect": {
  "build": {
    [...],
    "styles": [
      "src/styles.css",
        "node_modules/bootstrap/dist/css/bootstrap.min.css"
      ],
      "scripts": [
        "node_modules/jquery/dist/jquery.min.js",
        "node_modules/bootstrap/dist/js/bootstrap.min.js"
      ]

    },

******************************************************************************

YANG / OpenDaylight / OpenFlow / SDN

What is YANG?

YANG is a specialised schema language, similar to XSD Schema or RelaxNG but (was) specific to NETCONF.

Its goal is to model all content that is exchanged during protocol sessions between peers, as described in RFC6020:
YANG is a language used to model data for the NETCONF protocol. A YANG module defines a hierarchy of data that can be used for NETCONF- based operations, including configuration, state data, Remote Procedure Calls (RPCs), and notifications. This allows a complete description of all data sent between a NETCONF client and server.

There are tools and server implementations out there that simply consume the YANG module set (a YANG model) and are ready to be used as dummy implementations.

There are also tools that use the model to enable users to query a device, without actually implementing anything specific about the device. You could say that a set of YANG modules exposes the interface provided by a device. What you do with this interface is entirely up to you.

Development environment

1. Maven 3.5.2 or later
2. Java 8-compliant JDK
3. An appropriate Maven settings.xml file. A simple way to get the default OpenDaylight settings.xml file is: hit below URL and save file in .m2

https://raw.githubusercontent.com/opendaylight/odlparent/master/settings.xml

Java Interview Q_A

1) Define abstraction and what is the difference between abstract class and interface?
2) Can abstract class have constructor method?

3) How will we invoke abstract class constructor?

4) How will we invoke abstract class parameterized constructor?

5) Does java.util.List.isEmpty() check if the list itself is null? - No

6) How to get first item from a java.util.Set? - collection.stream().findFirst()

7) Why does findFirst() throw a NullPointerException if the first element it finds is null?

https://stackoverflow.com/questions/32466799/why-does-findfirst-throw-a-nullpointerexception-if-the-first-element-it-finds 

8)  Can we break out of a forEach loop when going through an Array? - No

There is no way to stop or break a forEach() loop other than by throwing an exception. If you need such behaviour, the . forEach() method is the wrong tool, use a plain loop instead.

9) 

DevOps

Continuous Development
Developers uses tools to develop the code. Developed code get pushed to source code management. - Visual Studio, Eclipse, Intellij
devops engineers are responsible to maintain the code using "source code management tools" - git, bitbucket, mercurial, svn
Continuous Integration - jenkins, bamboo, circleci, teamcity
Unit Testing - junit, testng
Code build - maven, ant, gradle
Code Analysis - SonarQube
Code Artifacts - Nexus
Continuous Deployment - Ansible, jenkins, puppet, AWS code deploy
Infrastructure - docker, kubernetes, AWS, Azure
Configuration Management - Ansible
Continuous Testing - selenium
Continuous Monitoring - Nagios

ReactJS library - develop modern web apps

Based on MVC architecture, React JS library provides developers with the ability to create dynamic web page templates (e.g., pages with an extensive amount of interactive elements on them).

ReactJS is not a framework. ReactJS describes itself as the V in the MVC (Model-View-Controller) design pattern. It's a view library that you can combine with frameworks such as AngularJS, Ember, and Meteor or even in conjunction with other popular JavaScript libraries, such as Knockout.

Many people use React on its own and combine it with a data flow pattern called Flux. The idea behind Flux is to establish unidirectional data flow, meaning that data should originate at a single point in your app and flow downwards.

Installation
1) install Node.js, npm
2) After that, install create-react-app package as below:-
$ npm install -g create-react-app

It is possible to manually create a React app, but Facebook has created a node module create-react-app to generate a boilerplate version of a React application.

Now create a New Single-Page React App by using create-react-app Package
$ npx create-react-app webshop

commands to run :-
npm start - starts the development server
npm run build - bundles the app into static files for production
npm test - starts the test runner
npm run eject - removes this tool and copies build dependencies, configuration files and scripts into app directory.

Understanding the Project Structure



/src/index.js

import React from "react";
import ReactDOM from "react-dom";

//JSX
ReactDOM.render(<h1>Hello World</h1>, document.getElementById("root"));

We are telling React what do we want to render (first argument), and where do we want this to be rendered (second argument).

Let's start with the first one.
Probably you wonder why are you putting an HTML element in the middle of your JavaScript parameter?
Fortunately, React creators created a language called JSX.  JSX (JavaScript XML) is an extension to the JavaScript language syntax. It is very much like a JavaScript rendition or version of HTML, in fact we're going to see that most of JSX looks almost identical to HTML with those few slight differences.

So this is a reason why do we have to import React in the first line.  The React library is the one that will enable JSX to work the way it's supposed to work.

In fact if  you remove or comment out the import React line and try to save it and refresh the browser, it tells me that React is not defined even though we're not explicitly using React anywhere in my code.

public/index.html

<div id="root"></div>

Although the initial div is empty, ReactDOM.render() is actually attaching React code to the container dynamically. Obviously, we do not have to attach it to root. We can attach it to any other valid DOM element:

<div id="static">Static Content1</div><div id="root"></div><div id="static">Static Content2</div>

React.Fragment
You cannot render two JSX objects next to each other. It will cause an error. But instead they have to be wrapped in something so that they count as just one element with two elements inside for example

ReactDOM.render(<h1>Hello World</h1><h2>Sub heading</h2>, document.getElementById("root"));

ReactDOM.render(
    <div>
      <h1>Hello World</h1>
      <h2>Sub heading</h2>
    </div>,
    document.getElementById("root")
  );

If you don't want to wrap it with an extra div, there is a way to do that as well. Instead of div, simply use the special container - <React.Fragment>.

  ReactDOM.render(
    <React.Fragment>
      <h1>Hello World</h1>
      <h2>Sub heading</h2>
    </React.Fragment>,
    document.getElementById("root")
  );

App class
This is the definition of main class. For now, think of a class as of definition of the component.

class App extends Component {
    constructor(props) { ... }
        render() {
        return (..);
        }
    }

Whenever React renders (is mounting) some class (components) it executes a few functions in a certain order. For now, just remember that constructor() is called before the render() function.

Mounting phase
These methods are called in the following order when an instance of a component is being created and inserted into the DOM:

constructor()
getDerivedStateFromProps()
render()
componentDidMount()

functions() — after calling the constructor we have a few functions that are used within the application.
render() — this function you already know. It contains JSX code that will be rendered to the browser.

Creating a Web Shop

React focuses on a core set of the features that are required by web applications :-
core react libraries - react, react-dom, react-scripts

React relies on supporting packages to create complete applications :-
bootstrap - This package provides the CSS styles that is used to present HTML content.
fontawesome-free - This package provides icons that can be included in HTML content.
redux - This package provides a data store, which simplifies the process of coordinating the different parts of the application.
react-redux - This package integrates a Redux data store into a React application.
react-router-dom  - This package provides URL routing, which allows the content presented to the user to be selected based on the browser’s current URL.
axios - This package is used to make HTTP requests and will be used to access RESTful and
GraphQL services.
graphql - This package contains the reference implementation of the GraphQL specification.
apollo-boost - This package contains a client used to consume a GraphQL service.
react-apollo - This package is used to integrate the GraphQL client into a React application.

When creating any kind of website, it's often beneficial to create a mock-up of how you want the page to look before proceeding to write any code.  This makes it easier to visualize how you want your site to look and what components you need to create.

You can use any kind of mock-up tool to create this, even a sheet of paper will do.

Looking at our website mock-up, we can see that we need to create the following components:
• A layout component
• A home page component for the front page
• A menu component with a brand name and the most important links
• A company information component
• A product list component
• An item component
• A checkout component
• A receipt component

These are just the view components.

In addition to these, we'll need to create data stores and actions and sub-components for the main ones.

Creating the layout
First of all, we need a basic layout for our webshop. There are many options available for you.
For instance, you can choose any one of the many open source CSS frameworks, such as Bootstrap or Foundation, or you can strike your own path and build up a basic grid and bring in elements as you see fit.

For simplicity's sake, we'll be going with Bootstrap for this webshop. It's a hugely popular framework that is easy to work with and has excellent support for React.

Add a few more packages -
react-bootstrap, react-router, lodash, reflux, superagent and react-router-bootstrap.
npm install --save <package>

This will put these packages in regular dependencies section in package.json

In order for the smart phones to show the page in proper scale, we need to add this meta tag as well:

<meta name="viewport" content="width=device-width, initialscale=1">

This notifies the smart phone browser that you want to display the page in full width with a scale of 1. You can play with the scale and width, but in most cases, this setting is what you want.


Adding your own CSS code
We already have a CSS file in the src folder. We're going to use a very basic CSS layout and rely on Bootstrap for the most part. Edit src/app.css and replace it with the following code:

body {
  background:#eee;
  padding:62px 0 0 0;
 }
 .row {
  padding:0 0 20px 0;
 }
 .summary {
  border-bottom: 3px double black;
 }

The padding is there simply to make sure that the content falls inside the menu.

Adding a route handler
Create a file called router.jsx and also a new file called layout.jsx, which will be our primary route handler.  This is where the contents of your route changes will go. Everything you put around it will not be changed when you switch to a new route, so this is where you place static elements, such as headers, footers, and asides.

The menu and footer
It's time to start working on the visible menu components. Let's begin with the menu and the footer. Looking at our mock-up, we see that we want to build a full-width section with the brand name of the shop and the menu links, and at the bottom, we want a single centered line of text with a copyright notice.

We'll do this by adding the following import to our import section in the layout.jsx file:
import Menu from "./components/menu.jsx";

import Footer from "./components/footer";

Let's scan the JSX code. Our app is split into two columns using Bootstrap grid (Container, Rows, and Columns) thanks to that columns will either be displayed next to each other (large screen) or one below the other.

AOP extends OOP

OOP is mainly used to organise your business logic while AOP helps to organise your non-functional things like Auditing, Logging, Transaction Management , Performance Tracking, Security etc

This way you can decouple your business logic with non-fictional logic that makes code cleaner.

OOP and AOP are not mutually exclusive. AOP can be good addition to OOP.


AOP provides a nice way to implement cross-cutting concerns like logging, performance tracking, security over different classes in your application without having to change the classes themselves.
 
These cross-cutting concerns are pieces of logic that have to be applied at many places but actually don't have anything to do with the business logic.

You shouldn't see AOP as a replacement of OOP, more as an nice add-on, that makes your code more clean, loosely-coupled and focused on the business logic. So by applying AOP you will get 2 major benefits:

1. The logic for each concern is now in one place, as opposed to being scattered all over the code base.

2. classes are cleaner since they only contain code for their primary concern (or core functionality) and secondary concerns have been moved to aspects.

This is a way of doing runtime-weaving.

Example;-

1. Assume you have a graphical class with many "set()" methods.
2. After each set() method, the data of the graphics changed, thus the graphics changed and thus the graphics need to be updated on screen.
3. Assume to repaint the graphics you must call "Display.update()".

The classical approach is to solve this by adding more code. At the end of each set method you write

void set(...) {
    :
    :
    Display.update();
}

If you have 3 set-methods, that is not a problem. If you have 200 (hypothetical), it's getting real painful to add this everywhere.

Also whenever you add a new set-method, you must be sure to not forget adding this to the end, otherwise you just created a bug.

AOP solves this without adding tons of code, instead you add an aspect:

after() : set() {
   Display.update();
}


And that's it! Instead of writing the update code yourself, you just tell the system that after a set() pointcut has been reached, it must run this code and it will run this code.


No need to update 200 methods, no need to make sure you don't forget to add this code on a new set-method. Additionally you just need a pointcut:

pointcut set() : execution(* set*(*) ) && this(MyGraphicsClass) && within(com.company.*);

What does that mean? That means if a method is named "set*" (* means any name might follow after set), regardless of what the method returns (first asterisk) or what parameters it takes (third asterisk) and it is a method of MyGraphicsClass and this class is part of the package "com.company.*", then this is a set() pointcut. And our first code says "after running any method that is a set pointcut, run the following code".

See how AOP elegantly solves the problem here? Actually everything described here can be done at compile time. A AOP preprocessor can just modify your source (e.g. adding Display.update() to the end of every set-pointcut method) before even compiling the class itself.

Optimize Queries for Speed and Performance

Tip #1: Index All Columns Used in 'where', 'order by', and 'group by' Clauses

Though indexes may take up more space and decrease performance on inserts, deletes, and updates.
However, indexes can considerably reduce select query execution time.

without index => full table scan

mysql> select customer_name from customers where customer_id='140385';
The above query will force Database server to conduct a full table scan (start to finish) to retrieve the record that we are searching.
Database server has a special 'EXPLAIN' statement that you can use alongside select, delete, insert, replace and update statements to analyze your queries.

Once you append the query before an SQL statement,
mysql> explain select customer_id, customer_name from customers where customer_id='140385';
Server displays information from the optimizer about the intended execution plan.

+----+-------------+-----------+------------+------+---------------+------+---------+------+------+----------+-------------+
| id | select_type | table     | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra       |
+----+-------------+-----------+------------+------+---------------+------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | customers | NULL       | ALL  | NULL          | NULL | NULL    | NULL |  500 |    10.00 | Using where |
+----+-------------+-----------+------------+------+---------------+------+---------+------+------+----------+-------------+

As you can see, the optimizer has displayed very important information that can help us to fine-tune our database table.
First, it is clear that MySQL will conduct a full table scan because key column is 'NULL'.
Second, MySQL server has clearly indicated that it's going to conduct a full scan on the 500 rows in our database.
To optimize the above query, we can just add an index to the 'customer_id' field.

If we run the explain statement one more time, we will get the below results:

mysql> Explain select customer_id, customer_name from customers where customer_id='140385';
+----+-------------+-----------+------------+------+---------------+-------------+---------+-------+------+----------+-------+
| id | select_type | table     | partitions | type | possible_keys | key         | key_len | ref   | rows | filtered | Extra |
+----+-------------+-----------+------------+------+---------------+-------------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | customers | NULL       | ref  | customer_id   | customer_id | 13      | const |    1 |   100.00 | NULL  |
+----+-------------+-----------+------------+------+---------------+-------------+---------+-------+------+----------+-------+

From the above explain output, it's clear that MySQL server will use our index (customer_Id) to search the table.
You can clearly see that the number of rows to scan will be 1. Although I run the above query in a table with 500 records, indexes can be very useful when you are querying a large dataset (e.g. a table with 1 million rows).


Tip 2: Optimize Like Statements With Union Clause

Sometimes, you may want to run queries using the comparison operator 'or' on different fields or columns in a particular table. When the 'or' keyword is used too much in where clause, it might make the MySQL optimizer to incorrectly choose a full table scan to retrieve a record.

A union clause can make the query run faster especially if you have an index that can optimize one side of the query and a different index to optimize the other side.

Example, consider a case where you are running the below query with the 'first_name' and 'last_name' indexed:

mysql> select * from students where first_name like  'Ade%'  OR last_name like 'Ade%' ;
The query above can run far much slower compared to the below query which uses a union operator merge the results of 2 separate fast queries that takes advantage of the indexes.

mysql> select  from students where first_name like  'Ade%'  UNION ALL select  from students where last_name like 'Ade%' ;

Tip 3: Avoid Like Expressions With Leading Wildcards

MySQL is not able to utilize indexes when there is a leading wildcard in a query. If we take our example above on the students table, a search like this will cause MySQL to perform full table scan even if you have indexed the 'first_name' field on the students table.

mysql> select * from students where first_name like  '%Ade'  ;

We can prove this using the explain keyword:

mysql> explain select * from students where first_name like  '%Ade'  ;
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+-------------+
| id | select_type | table    | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra       |
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | students | NULL       | ALL  | NULL          | NULL | NULL    | NULL |  500 |    11.11 | Using where |
+----+-------------+----------+------------+------+---------------+------+---------+------+------+----------+-------------+
As you can see above, MySQL is going to scan all the 500 rows in our students table and make will make the query extremely slow.

Tip 4: Take Advantage of MySQL Full-Text Searches

If you are faced with a situation where you need to search data using wildcards and you don't want your database to underperform, you should consider using MySQL full-text search (FTS) because it is far much faster than queries using wildcard characters.

Furthermore, FTS can also bring better and relevant results when you are searching a huge database.

To add a full-text search index to the students sample table, we can use the below MySQL command:

mysql>Alter table students ADD FULLTEXT (first_name, last_name);
mysql>Select * from students where match(first_name, last_name) AGAINST ('Ade');
In the above example, we have specified the columns that we want to be matched (first_name and last_name) against our search keyword ('Ade').

If we query the optimizer about the execution plan of the above query, we will get the following results:

mysql> explain Select * from students where match(first_name, last_name) AGAINST ('Ade');
+----+-------------+----------+------------+----------+---------------+------------+---------+-------+------+----------+-------------------------------+
| id | select_type | table    | partitions | type     | possible_keys | key        | key_len | ref   | rows | filtered | Extra                         |
+----+-------------+----------+------------+----------+---------------+------------+---------+-------+------+----------+-------------------------------+
|  1 | SIMPLE      | students | NULL       | fulltext | first_name    | first_name | 0       | const |    1 |   100.00 | Using where; Ft_hints: sorted |
+----+-------------+----------+------------+----------+---------------+------------+---------+-------+------+----------+-------------------------------+
It's clear that only a single row will be scanned even if our student's database has 500 rows and this will speed up the database.


LIKE vs CONTAINS on SQL Server

Which one of the following queries is faster (LIKE vs CONTAINS)?

SELECT * FROM table WHERE Column LIKE '%test%';
or
SELECT * FROM table WHERE Contains(Column, "test");


The second should be faster, because it can use some form of index (in this case, a full text index).
Of course, this form of query is only available if the column is in a full text index. If it isn't, then only the first form is available.

The first query, using LIKE, will be unable to use an index, since it starts with a wildcard, so will always require a full table scan.

***********************************************************************

Optimize Your Database Schema
Even if you optimize your MySQL queries and fail to come up with a good database structure, your database performance can still halt when your data increases.

Normalize Tables
First, normalize all database tables even if it will involve some trade-offs. For instance, if you are creating two tables to hold customers data and orders, you should reference the customer on the orders table using the customer id as opposed to repeating the customer's name on the orders table. The latter will cause your database to bloat.

The image below refers to a database schema that is designed for performance without any data redundancy. In MySQL database normalization, you should represent a fact only once in the entire database. Don't repeat the customer name in every table; instead just use the customer_Id for reference in other tables.



Also, always use the same data type for storing similar values even if they are on different tables, for instance, the schema above uses 'INT' data type to store 'customer_id' both in the customers and orders table.

Use Optimal Data Types
MySQL supports different data types including integer, float, double, date, date_time, Varchar, and text, among others. When designing your tables, you should know that "shorter is always better."

For instances, if you are designing a system user's table which will hold less than 100 users, you should use 'TINYINT' data type for the 'user_id' field because it will accommodate all your values from -128 to 128.

Also, if a field expects a date value (e.g. sales_order_date), using a date_time data type will be ideal because you don't have to run complicated functions to convert the field to date when retrieving records using SQL.

Use integer values if you expect all values to be numbers (e.g. in a student_id or a payment_id field). Remember, when it comes to computation, MySQL can do better with integer values as compared to text data types such as Varchar

Avoid Null Values
Null is the absence of any value in a column. You should avoid this kind of values whenever possible because they can harm your database results. For instance, if you want to get the sum of all orders in a database but a particular order record has a null amount, the expected result might misbehave unless you use MySQL 'ifnull' statement to return alternative value if a record is null.

In some cases, you might need to define a default value for a field if records don't have to include a mandatory value for that particular column/field.

Avoid Too Many Columns
Wide tables can be extremely expensive and require more CPU time to process. If possible, don't go above a hundred unless your business logic specifically calls for this.

Instead of creating one wide table, consider splitting it apart in to logical structures. For instance, if you are creating a customer table but you realize a customer can have multiple addresses, it is better to create a separate table for holding customers addresses that refer back to the customers table using the 'customer_id' field.

Optimize Joins
Always include fewer tables in your join statements. An SQL statement with poorly designed pattern that involves a lot of joins may not work well. A rule of thumb is to have utmost a dozen joins for each query.

MySQL Query Caching
If your website or application performs a lot of select queries (e.g. WordPress), you should take advantage of MySQL query caching feature. This will speed up performance when read operations are conducted.

The technology works by caching the select query alongside the resulting data set. This makes the query run faster since they are fetched from memory if they are executed more than once. However, if your application updates the table frequently, this will invalidate any cached query and result set.

You can check if your MySQL server has query cache enabled by running the command below:

mysql> show variables like 'have_query_cache';
+------------------+-------+
| Variable_name    | Value |
+------------------+-------+
| have_query_cache | YES   |
+------------------+-------+
1 row in <b>set</b> (0.00 sec)
Setting the MySQL Server Query Cache
You can set the MySQL query cache values by editing the configuration file ('/etc/mysql/my.cnf' or '/etc/mysql/mysql.conf.d/mysqld.cnf'). This will depend on your MySQL installation. Don't set a very large query cache size value because this will degrade the MySQL server due to cached overhead and locking. Values in the range of tens of megabytes are recommended.

To check the current value, use the command below:

mysql> show variables like 'query_cache_%' ;
+------------------------------+----------+
| Variable_name                | Value    |
+------------------------------+----------+
| query_cache_limit            | 1048576  |
| query_cache_min_res_unit     | 4096     |
| query_cache_size             | 16777216 |
| query_cache_type             | OFF      |
| query_cache_wlock_invalidate | OFF      |
+------------------------------+----------+
5 rows in <b>set</b> (0.00 sec)
Then to adjust the values, include the following on the MySQL configuration file:

query_cache_type=1
query_cache_size = 10M
query_cache_limit=256k
You can adjust the above values according to your server needs.

The directive 'query_cache_type=1' turns MySQL caching on if it was turned off by default.

The default 'query_cache_size' is 1MB and like we said above a value a range of around 10 MB is recommended. Also, the value must be over 40 KB otherwise MySQL server will throw a warning, "Query cache failed to set size".

The default 'query_cache_limit' is also 1MB. This value controls the amount of individual query result that can be can be cached.