Education World

10/16/2013

Written By Ashly Dominic on Wednesday, October 16, 2013 | 10/16/2013

Getting Start With SEO(Search Engine Optimaization)

Learn IMRI's scientific approach to Search Engine Optimization (SEO) including keyword research, competitive analysis, information architecture, pre-site audit, html optimization, seo content writing, link baiting, seo tools, universal seo, mobile seo, advanced social seo strategies, reporting, and highly-relevant, proven link building tactics; plus get certified in Search Engine Optimization (SEO) for better career and business prospects!

SEO Basics

SEO (Search Engine Optimization) is the activity of optimizing Web pages or whole sites in order to make them more search engine friendly, thus getting higher positions in search results.

Create unique, accurate page titles
Make use of the "description" meta tag
Improving Site Structure
Improve the structure of your URLs
Make your site easier to navigate
Optimizing Content
Offer quality content and services
Write better anchor text
Optimize your use of images
Use heading tags appropriately
Dealing with Crawlers
Make effective use of robots.txt
Be aware of rel="nofollow" for link

Create unique, accurate page titles

A title tag tells both users and search engines what the topic of

a particular page is. The <title> tag should be placed within the

<head> tag of the HTML document . Ideally, you should create a

unique title for each page on your site.

Eg:<html>

<head>

<title>Brandon's Baseball Cards - Buy Cards, Baseball News, Card Prices</title>

large selection of vintage and modern baseball cards for sale. We also offer

daily baseball news and events in">

</head

Make use of the "description" meta tag

A page's description meta tag gives Google and other search

engines a summary of what the page is about Whereas a

page's title may be a few words or a phrase, a page's description meta

tag might be a sentence or two or a short paragraph. Google

Webmaster Tools provides a handy content analysis section that'll tell

you about any description meta tags that are either too short, long, or

duplicated too many times (the same information is also shown for

<title> tags). Like the <title> tag, the description meta tag is placed

within the <head> tag of your HTML document.

Eg:<html>

<head>

<title>Brandon's Baseball Cards - Buy Cards, Baseball News, Card Prices</title>

large selection of vintage and modern baseball cards for sale. We also offer

daily baseball news and events in">

</head

Improving Site Structure

Simple-to-understand URLs will convey

content information easily

URLs are displayed in search results

with the URL listed under the title and snippet.Creating descriptive categories and filenames for the documents onyour website can not only help you keep your site better organized,but it could also lead to better crawling of your documents bysearch engines.

Also, it can create easier, "friendlier" URLs for thosethat want to link to your content. Visitors may be intimidated by extremely long and cryptic URLs that contain few recognizable words.URLs like can be confusing and unfriendly. Users would have ahard time reciting the URL from memory or creating a link to it. Also,users may believe that a portion of the URL is unnecessary, especially if the URL shows many unrecognizable parameters. They might leave off a part, breaking the link.Some users might link to your page using the URL of that page as the anchor text. If your URL contains relevant words, this provides users and search engines with more information about the page than an ID or oddly named parameter would

Make your site easier to navigate

The navigation of a website is important in helping visitors quickly find the content they want. It can also help search engines understand what content the webmaster thinks is important. Although Google's search results are provided at a page level, Google also likes to have a sense of what role a page plays in the bigger
picture of the site. All sites have a home or "root" page, which is usually the most
frequented page on the site and the starting place of navigation for many visitors. Unless your site has only a handful of pages, you should think about how visitors will go from a general page
(your root page) to a page containing more specific content.

Do you have enough pages around a specific topic area that it would make sense to create a page describing these related pages (e.g. root page -> related topic listing -> specific topic)? Do you have hundreds of different products that need to be classified under multiple category and subcategory pages

Optimizing Content

Create a naturally flowing hierarchy
creating complex webs of navigation links, e.g. linking every page on your site to every other page
going overboard with slicing and dicing your content (so that it takes twenty clicks)
Avoid: Make it as easy as possible for users to go from general content to the more specific content they
want on your site. Add navigation pages when it makes sense and effectively work these into your
internal link structure.

Use mostly text for navigation

Avoid:Glossary Controlling most of the navigation from page to page on your site through text links makes it easier for search engines to crawl and understand your site. Many users also prefer this over other approaches, especially on some devices that might not handle Flash or JavaScript. having a navigation based entirely on drop-down menus, images, or animations - many, but not all, search engines can discover such links on a site, but if a user can reach all pages on a site via normal text links, this will improve the accessibility of your site.

Offer quality content and services

Interesting sites will increase their
recognition on their own (1) A blogger finds a piece of your content, likes it, and then references it in a blog
post. (2) The Google AdWords Keyword Tool can help you find relevant keywords on your site and the volume of those keywords.
Glossary
Anticipate differences in users' understanding of your topic and offer unique, exclusive content Creating compelling and useful content will likely influence your website more than any of the other factors discussed here Users know good content when they see it and will likely want to direct other users to it. This could be through blog posts, social media services, email, forums, or other means. Organic or word-of-mouth buzz is what helps build your site's reputation with both users and Google, and it rarely comes without
quality content. Think about the words that a user might search for to find a piece of your content. Users who know a lot about the topic might use different keywords in their search queries than someone who is new to the topic. For example, a long-time baseball fan might search for [nlcs], an acronym for the National League Championship Series, while a new fan might use a more general query like [baseball playoffs]. Anticipating these differences in search behavior and accounting for them while writing your content (using a good mix of keyword phrases) could produce positive results. Google AdWords provides a handy Keyword Tool that helps you discover new keyword variations and see the approximate search volume for each keyword (2). Also, Google Webmaster Tools provides you with the top search queries your site appears for and the ones that led the most users to your site

Write better anchor text

Suitable anchor text makes it easy to convey the contents linked This text tells users and Google something about the page you're linking to. Links on your page maybe internal—pointing to other pages on your site—or external—leading to content on other sites. In either of these cases, the better your anchor text is, the easier it is for users to navigate and for Google to understand what the page you're linking to is about

Optimize your use of images

Image-related information can be provided for by using the "alt" attribute Images may seem like a straightforward component of your site, but you can optimize your use of them. All images can have a distinct

filename and "alt" attribute, both of which you should take advantage of. The "alt" attribute allows you to specify alternative text for the image if it cannot be displayed for some reason (1). Why use this attribute? If a user is viewing your site on a browser that doesn't support images, or is using alternative technologies, such as a screen reader, the contents of the alt attribute provide information about the picture. Another reason is that if you're using an image as a link, the alt text for that image will be treated similarly to the anchor text of a text link. However, we don't recommend using too many images for links in your site's navigation when text links could serve the same purpose. Lastly, optimizing your image filenames and alt text makes it easier

for image search projects like Google Image Search to better

Use heading tags appropriately

Heading tags (not to be confused with the <head> HTML tag or HTTP headers) are used to present structure on the page to users. There are six sizes of heading tags, beginning with <h1>, the most important, and ending with <h6>, the least important . Since heading tags typically make text contained in them larger than normal text on the page, this is a visual cue to users that this text is important and could help them understand something about the type of content underneath the heading text. Multiple heading sizes used in order create a hierarchical structure for your content,making it easier for users to navigate through your document.

Make effective use of robots.txt

A "robots.txt" file tells search engines whether they can access and therefore crawl parts of your site (1). This file, which must be named "robots.txt", is placed in the root directory of your site You may not want certain pages of your site crawled because they might not be useful to users if found in a search engine's search

results. If you do want to prevent search engines from crawling your pages, Google Webmaster Tools has a friendly robots.txt generator to help you create this file. Note that if your site uses subdomains and you wish to have certain pages not crawled on a particular subdomain, you'll have to create a separate robots.txt file for that subdomain. For more information on robots.txt.

Be aware of rel="nofollow" for link

Combat comment spam with "nofollow" Automatically add "nofollow" to comment columns and message boards A comment spammer leaves a message on one of our blogs posts, hoping to get some of our site's reputation. Be aware of rel="nofollow" for links Dealing with Crawlers It can present a challenge to try to ensure an actual person is leaving the comment. Setting the value of the "rel" attribute of a link to "nofollow" will tell Google that certain links on your site shouldn't be followed or pass your page's reputation to the pages linked to. Nofollowing a link is adding rel="nofollow" inside of the link's anchor

When would this be useful? If your site has a blog with public commenting turned on, links within those comments could pass your reputation to pages that you may not be comfortable vouching for. Blog comment areas on pages are highly susceptible to comment spam (2). Nofollowing these user-added links ensures that you're not giving your page's hard-earned reputation to a spammy site. Many blogging software packages automatically nofollow user comments, but those that don't can most likely be manually edited to do this. This advice also goes for other areas of your site that may involve user-generated content, such as guestbooks, forums, shoutboards, referrer listings, etc. If you're willing to vouch for links added by third parties (e.g. if a commenter is trusted on your site), then there's no need to use nofollow on links; however, linking to sites that Google considers spammy can affect the reputation of yourown site. The Webmaster Help Center has more tips on avoiding.

5/24/2013

Learn C++ in 12 days - Day 12

Written By Ente Malayalam on Friday, May 24, 2013 | 5/24/2013

DAY - 1

DAY - 2

DAY - 3

DAY – 4

DAY – 5

DAY – 6

DAY – 7

DAY – 8

DAY – 9

DAY – 10

DAY – 11

DAY– 12

By yesterday, we have finished the first two major steps of object oriented programming

- Abstraction

- Encapsulation

If we take our first example, Car dealer ship system, after the above two examples, all the real world entities are practically implemented in terms of classes and objects. As we said before, the system will have a meaning only when all these entities work together in a co-operative manner. Or I should say, system will have a meaning only when proper relationships are established between the different entities. That exactly is our next step.

Establishing Relationships :

We will take the same relationship diagrams which we established in our first class. Let me put it diagrammatically wilth UML notations here.

We have currently represented it diagrammatically. Our next job is to practically implement it. So lets start with association.

Association:

As I have already told you, the relationship association comes into picture when two entities are related for some specific functionality. For eg: if you consider customer and car, they are related for functionalities like either buy a car or configure a car. Mean while change in one entity is not going to effect the associated entity.

Talking about the implementation, if I take the same example, the entity called car comes into picture only for the specific behaviour or customer ie) buy or configure a car. Ie) an object of car should come into existence when the behaviour buy or configure car is invoked and as expected it will go out of existence once the functionality is over. Keeping these things in mind and implementing it (we will implement it for configure a car)

//car.h

#include <iostream>

using namespace std;

class Aclass_Car {

private:

char Model_Name[20];

int Speed;

int Mileage;

public:

Aclass_Car() {}

Aclass_Car(char *n, int s, int m) {

strcpy(Model_Name, n);

Speed = s;

Mileage = m;

}

void Set_Speed(int);

void Set_Mileage(int);

void Move();

};

//car_library.cpp

#include "car.h"

void Aclass_Car :: Set_Speed(int s) {

Speed = s;

}

void Aclass_Car :: Set_Mileage(int m) {

Mileage = m;

}

void Aclass_Car :: Move() {

cout << "Car is moving with a speed of " << Speed << "km/hour and";

cout << "a mileage of " << Mileage << endl;

}

//customer.h

#include <iostream>

using namespace std;

class Customer {

private:

char Customer_Name[20];

int Reference_Id;

public:

Customer() {}

Customer(char *n, int r) {

strcpy(Customer_Name, n);

Reference_Id = r;

}

void Configure_Car();

};

//customer_library.cpp

#include "car.h"

#include "customer.h"

void Customer :: Configure_Car() {

Aclass_Car *Bmw = new Aclass_Car("BMW", 1, 1);

Bmw -> Set_Speed(30);

Bmw -> Set_Mileage(8);

Bmw -> Move();

delete Bmw;

}

//car_customer_application.cpp

#include "car.h"

#include "customer.h"

int main() {

Customer John("John Abraham", 12);

John.Configure_Car();

}

As you have noticed, the life span of the related entity car exists only for the specific functionality called Configure_Car();

Shared Aggregation:

Lets try to implement the shared aggregation relationship between car and ac. Here car and ac is having a whole part relationship but they are loosely coupled. In the sense, the life time of both the entities may not be same.

Talking about the implementation, If you consider ac and car, we can see that ac can be inserted or removed any time you want. But ac will surely be destroyed when the car gets destroyed. Keeping these things in mind, lets try to implement the shared aggregation here.

//ac.h

#include <iostream>

using namespace std;

class Ac {

private:

float Temperature;

public:

Ac() : Temperature(21.5) {}

void Set_Temperature(float);

};

//ac_library.cpp

#include "ac.h"

void Ac :: Set_Temperature(float t) {

Temperature = t;

}

//car.h

#include <iostream>

#include "ac.h"

using namespace std;

class Car {

private:

char Model_Name[20];

Ac *Aptr;

public:

Car() {}

Car(char *m) {

strcpy(Model_Name, m);

}

void Plug_Ac();

void Switch_On_Ac();

void Switch_Off_Ac();

~Car() {

if(Aptr != NULL)

delete Aptr;

}

};

//car_library.cpp

#include "car.h"

void Car :: Plug_Ac() {

Aptr = new Ac;

}

void Car :: Switch_On_Ac() {

float Temperature;

cout << "Enter the Temperature" << endl;

cin >> Temperature;

Aptr -> Set_Temperature(Temperature);

cout << "Ac is on and temperature is set to " << Temperature << " celsius" << endl;

}

void Car :: Switch_Off_Ac() {

Aptr -> Set_Temperature(0.0);

cout << "Ac is switched off" << endl;

}

//car_ac_application.cpp

#include "car.h"

int main() {

Car Bmw("BMW");

Bmw.Plug_Ac();

Bmw.Switch_On_Ac();

Bmw.Switch_Off_Ac();

}

Note , even though ac comes into picture in a behaviour Plug_Ac(), we have made sure that it gets destroyed when the car is destructed.

Composite Aggregation:

If you consider the relationship between Car and Engine, you can see that even they have whole part relationship but only difference here is they are strongly / tightly coupled. In the sense, the life time of both the entities will be same or in other words car doesn’t have any existence without any engine.

So talking about the implementation, engine should get constructed at the same time of construction of car and it should get destroyed at the time of destruction of car. Keeping these things in mind, lets try to establish composite aggregation between car and engine.

//engine.h

#include <iostream>

using namespace std;

class Engine {

private:

float Temperature;

int Cubic_Capacity;

public:

Engine() : Temperature(30.00), Cubic_Capacity(800) {}

void Start_Engine();

float Check_Temperature();

void Cool_Engine();

};

//engine_library.cpp

#include "engine.h"

void Engine :: Start_Engine() {

cout << "Engine Started" << endl;

Temperature += 200;

}

float Engine :: Check_Temperature() {

return Temperature;

}

void Engine :: Cool_Engine() {

cout << "Engine cooled...it s safe" << endl;

Temperature -= 200;

}

//car.h

#include <iostream>

#include "engine.h"

using namespace std;

class Car {

private:

char Model_Name[20];

Engine *Eptr;

public:

Car(char *m) {

strcpy(Model_Name, m);

Eptr = new Engine;

}

void Move_Car();

~Car() {

delete Eptr;

}

};

//car_library.cpp

#include "car.h"

void Car :: Move_Car() {

Eptr -> Start_Engine();

if (Eptr -> Check_Temperature() >= 100) {

cout << "Temperature crossess the limit" << endl;

cout << "cool it" << endl;

Eptr -> Cool_Engine();

}

//application.cpp

#include "car.h"

int main() {

Car Bmw("Bmw");

Bmw.Move_Car();

}

Dependency:

Considering the entities racing car and racing track, as we discussed before the ground clearance (which is directly related to suspension height) of the car depends upon the racing road. We can even call it as using relationship. One thing you can notice here is it is very similar to association. But here the change in features of one entity effects the other also. For eg: change in type of racing track effect the ground clearance of car.

Talking about the implementation, here since setting up the suspension of car checks the type of racing track which is a private property of the class racing track, dependency will be implemented using the concept of friends. Keeping all these things in mind, lets try to do the implementation.

//racing_track.h

#include <iostream>

#include "racing_car.h"

using namespace std;

class Racing_Track {

private:

char Track_Type[20];

public:

Racing_Track() {

strcpy(Track_Type, "Normal");

}

Racing_Track(char *t) {

strcpy(Track_Type, t);

}

friend void Racing_Car :: Set_Up_Suspension(Racing_Track);

};

//racing_car.h

#include <iostream>

using namespace std;

class Racing_Track;

class Racing_Car {

private:

int Ground_Clearance;

public:

Racing_Car() : Ground_Clearance(1300) {}

void Set_Up_Suspension(Racing_Track);

};

//racing_car_library.cpp

#include "racing_track.h"

void Racing_Car :: Set_Up_Suspension(Racing_Track Tobj) {

if (strcmp(Tobj.Track_Type, "Normal"))

cout << "current ground clearance is enough" << endl;

else

Ground_Clearance = 3000;

}

//racing_car_track_application.cpp

#include "racing_track.h"

int main() {

Racing_Car Ferrari;

Racing_Track Track_Normal;

Racing_Track Track_Rough("Rough");

Ferrari.Set_Up_Suspension(Track_Normal);

Ferrari.Set_Up_Suspension(Track_Rough);

}

Now the only relationship we left is inheritance or generalization. Our next 2 to 3 sessions will purely concentrate on that.

Reference : OOAD , Grady Booch

n stw �A' o �� s� 2.0pt;font-family:"Times New Roman","serif"'>}

main()

{

stack <int> s1;

s1.push(10);

s1.push(20);

s1.push(30);

cout << s1.pop() << endl;

stack <char> s2;

s2.push('a');

s2.push('b');

s2.push('c');

cout << s2.pop() << endl;

}

An eg with two generic data types:

Let s c an eg:

template <class T1, class T2>

class sample {

private:

T1 x;

T2 y;

public:

sample(T1 p, T2 q) {

x = p;

y = q;

}

void display();

};

template <class T1, class T2> void sample <T1, T2> :: display()

{

cout << x << endl;

cout << y << endl;

}

main()

{

sample <int, char> obj(10, 'a');

obj.display();

}

Education World

Latest Exam Results

Written By Ashly Dominic on Wednesday, October 16, 2013 | 10/16/2013

Getting Start With SEO(Search Engine Optimaization)

Make your site easier to navigate

Optimizing Content

Offer quality content and services

Write better anchor text

Optimize your use of images

Use heading tags appropriately

Make effective use of robots.txt

Learn C++ in 12 days - Day 12

Written By Ente Malayalam on Friday, May 24, 2013 | 5/24/2013

Hot Links

Approximate Date Result Picker

Recent Searches

Popular Post

Select University or State or Entrance Examination

Admission

Tamilnadu Education

2012 Results

Top Colleges in India

Random Post

Trending Topic