Domain Name Keywords

If your domain name contains an exact (or partial) match to a search query, chances
are it will show up on the first page of the SERPs—at least on Google. Google gives
keyword matching domains preferential treatment.
The exception to this rule is for competitive keywords. However, the chances of acquiring
a popular keyword domain are minimal, as most, if not all, dictionary words
are taken, in addition to the most popular two- or three-keyword phrase combinations.
This has led to the recent popularity of nonsense words as business names.
For niche keywords, you already won half the battle when you purchased your domain
name. Add an index page with related keywords, and you’ll be on the first page of
Google’s search results in a relatively short period of time.
You can use the following sample formats when creating your domain name:
http://www.keyword1-keyword2.com
http://www.keyword1keyword2keyword3.com
http://www.keyword.com
http://www.keyword.somedomain.com
http://keyword.basename.com
Note that the guidelines for subdomains are the same as for domains. The benefits of
subdomains are multifold, but subdomains can also be viewed as search engine spam
if you create too many of them. With subdomains, you can pick any name you like, as
you are in control of the domain record.

Read More

Optimize Your Site for Speed

Nobody has unlimited patience these days. Not everyone has high-speed Internet. Stay
away from (Flash) splash screens. Compress your media files for faster page loading.
Use media files only when you need to. Also make sure to describe your graphics,
videos, and sound files. For sound and video content, provide text transcripts. Make
use of thumbnails for large images. Use web server compression for your HTML web
server transmissions to speed up transmission for all your clients, including search
engine web spiders.

Read More

Use Intelligent Page Formatting

Try using smaller paragraphs with mixed-case text. Use boldface, italics, uppercase,
and different text color variations for emphasis. Employ browser-safe fonts such as
Times New Roman, Georgia (serif font), Arial, Helvetica, or Verdana (sans serif font).
Strategically employ bulleted lists, headings, and subheadings for clarity and information
organization. Using these options is helpful from an SEO perspective. Furthermore,
employ sufficient alignments, whitespace, and text padding for additional clarity
and web page look and feel.
Be mindful of web-safe colors. Use high-contrast color schemes for clarity and ease of
reading. Be consistent with colors. Don’t use too many colors. Try to stay away from
image backgrounds.

Read More

What is robots.txt?

Yes, that’s right! If you are not very careful with the robots.txt file, you could be blocking
web spiders from crawling content you do want to be indexed. Most reputable web
spiders will obey your instructions within robots.txt. So, be very careful when you use
and edit the robots.txt file. Also note that Google Webmaster Tools provides a
robots.txt checker, so you can enter a URL and confirm whether a given URL will be
crawled.

Read More

What Is a Sitemap?

using XML Sitemaps can help showcase
your most important links it would
be foolish not to utilize Webmaster Tools, as it is an indispensable resource for conducting
SEO.

Read More

Major Search Engine?

The name of bots/spider of Google search engineis GoogleBot, Yahoo Slurp for Yahoo search andBingBot for Bingsearch engine.

Read More

Why the Title Tag in Website is implemented for optimization?

Your page titles will show up in the SERPs, so make them concise and relevant.

Internal optimization refers to on-page and on-site activities. On-page activities include
keyword optimizations of <title> tags, description meta tags, page copy, and link
anchor text.

Concentrate on making easy, clear-cut, and logical interfaces with a focus on getting
to the right information quickly. Link anchor text should be of reasonable size and
should be similar to, or the same as, the destination page’s HTML title tag text (if it
exists).

TITLE element to identify the contents of a document. Since
users often consult documents out of context, authors should provide context-rich titles.
Thus, instead of a title such as “Introduction”, which doesn’t provide much contextual
background, authors should supply a title such as “Introduction to Medieval Bee-
Keeping” instead.
One of the most critical on-page factors, the <title> tag is not to be dismissed. Search
engines tend to use the <title> tag text as search results titles. All pages should have
unique page titles. All page titles should be crafted wisely, using the most important
keywords found in the page copy.

Read More

The svg element HTML5

The <svg> element allows the author to build a vector-based image directly in
the page using the SVG markup language.

<svg xmlns:xlink=”http://www.w3.org/1999/xlink”
xmlns=”http://www.w3.org/2000/svg”
viewBox=”0 0 200 100”
width=”200px” height=”100px”>
<circle cx=”50” cy=”50” r=”30”
style=”stroke:#0000ff; stroke-width: 5px;
fill:#ff0000;”/>
<rect x = ”100”
y = ”0”
height = ”50”
width = ”50”
stroke-width = ”2px”
stroke = ”#ffff00”
fill = ”#00ff00” />
</svg>

Read More

The context object drawing functionality HTML5

arc(): The arc command draws an arc (portion of a circle) as part of a
path. The arc is defined like a circle, with a center and radius, but also with
beginning and ending angles. If the angles describe a full circle (0 to 2 × pi
radians), the arc command will draw a full circle. See the preceding example
for a custom circle function created from the arc command.

beginPath(): This command begins the definition of a path. Normally a
path is defined by a single moveTo command, followed by a series of
lineTo commands, and finished by a stroke, closePath, or fill.

closePath(): This command connects the last point of a path (drawn
with moveTo and lineTo commands) to the first, creating a closed shape
that can be filled.

drawImage(): The drawImage command allows you to draw an image (from
an external image file) on the canvas. Many implementations allow pixel-level
manipulation, allowing you to apply custom filters and transformations to
your images, which allows far more control than the typical <img> tag.

 fill(): The fill command (and its variants — like fillRect) allows you to
apply the current fill style to elements drawn on the screen.

 fillRect(): This command builds a rectangle of a specified size and
position, filled in with the current fill style.

fillStyle(): Allows you to specify the fill style. This can be a standard
color value, or a predefined gradient.

 lineTo(): This command (along with the moveTo command) allows you
to build a path on the screen. The lineTo command takes a point as input
and draws from a previously defined point to the current point. Note that
the path is not displayed until the application of the stroke function.

lineWidth(): This defines the width of the line being drawn by a stroke
command.

 moveTo: Used in path definition, the moveTo command is used to indicate
the starting point of a path.

stroke(): This command draws the currently defined path. Note that
paths are not immediately drawn; the stroke command actually draws the
path on the screen.

Read More

The canvas tag HTML5

The <canvas> tag sets up a portion of the screen for program-controlled graphics.
The HTML simply sets aside a portion of the screen to be used as a canvas.
All the drawing and manipulation of the image is done through JavaScript code.
The following HTML code sets up a canvas element and provides a button.

<canvas id = “myCanvas”
width = “300”
height = “200”>
This example requires HTML5 canvas support
</canvas>
<button type = “button”
onclick = “draw()”>
click me to see a drawing
</button>



The canvas element does little on its own. To do anything interesting with the
canvas tag, use JavaScript to extract a drawing context (a special element that
can be drawn on) and use the methods of that context object to create dynamic
graphics. For example, here is the draw() function that will be enabled when
the user clicks the button

function draw(){
var myCanvas = document.getElementById(“myCanvas”);
var context = myCanvas.getContext(“2d”);
context.fillStyle = “blue”;
context.strokeStyle = “red”;
circle(context, 1, 1, 1);
for (i = 1; i <= 200; i+= 2){
circle(context, i, i, i, “blue”);
circle(context, 300-i, 200-i, i, “red”);
circle(context, 300-i, i, i, “blue”);
circle(context, i, 200-i, i, “red”);
} // end for
} // end draw
function circle(context, x, y, radius, color){
context.strokeStyle = color;
context.beginPath();
context.arc(x, y, radius, 0, Math.PI * 2, true);
context.stroke();
} // end circle

Read More