The New Google Algorithm Farmer- What SEO/SEM Professionals Need to Know

It's official! While there has been talk of an upcoming algorithm change from Google for at least a couple of months, these past couple of weeks saw a definite change in the way that Google ranks those sites on the web vying for top placement in its listings. So what is the big news? This algorithm specifically went after content farms and in addition to a broad extent low quality sites that have been gaming the system for higher rankings. Since the algorithm targeted content farmers, this algorithm has been nicknamed The Farmer. 
If you read our recent article: "Google Moving Against Content Farms- What Does This Mean for SEO?" You probably were already on the look-out for the coming algorithm change. Now that the algorithm has taken effect, the SEO/SEM community definitely knows a little bit more about it, however there are still a few things that require more research and information. 

Who Was Targeted by the Farmer Algorithm? 

This algorithm change which took effect since late February is said to have affected between 11% and 12% of the search queries in the United States. As of the moment, it is not sure when the algorithm will affect other regions in the world. 

Some of the major website properties that were affected included article distribution sites, aggregated content sites (those sites that republish original content from others), sites that mostly sell products with little or no content associated with them, and in general sites that don't have unique or high quality content. Generally speaking, if a website's goal is to monetize content that is not original or high quality, then it is likely that the site has been targeted by Google. 

Who Has Benefited from the Farmer Algorithm? 

Generally speaking, those sites that have or will benefit from this algorithm will be sites that create unique, high quality content. Obviously, white hat SEO always included creating high quality, unique content as a prerequisite for obtaining long term quality results, this fact hasn't changed. 

Tips for SEO/SEM to Avoid the Wrath of Farmer 

If you noticed a sudden drop in the Search engine result pages or if you want to avoid a sudden drop in the future, here are some tips that should help you avoid the raft of the Farmer algorithm. 

Make sure that the vast majority of content that you post on your website is unique and original. Obviously, you may have to post product descriptions or technical specs that come from a manufacturer, however when possible, create original and unique content in addition to this republished content. 

Consider using the Original Source meta tag from Google: meta name="original-source" content=http://www.somedomain.com/article1.html More information at: http://www.google.com/support/news_pub/bin/answer.py?answer=191283 

This meta tag directly tells Google that the content you have on your site is original- this way if someone plagiarizes your content or duplicates it in anyway, Google will know the original source and you should get all the credit from Google. 

Another good tool to checkout is at www.copyscape.com This tool will scan the net looking for duplicate content so that you can identify specific pages on your website that need to be re-written so they are 100% unique. 

Be choosy with the type of articles that you distribute. It should be noted that while Google has targeted many article distribution sites, you will not be penalized for having your content on these sites- the more likely possibility will be these back links will have less power and thus be less effective- so there is no need to remove any of your content from these sites. 

Be careful how you monetize your content. Obviously, those that heavily advertise on their site will receive extra scrutiny from Google. If you use content to lure traffic for monetization, definitely use unique content and do not rely solely on aggregated/republished content. 

Obviously, the Farmer algorithm has only been out for a couple of weeks, so SEO/SEM professionals are still researching its broad effects. As always, we'll keep you updated as well if we find important information.

Read More

List of Programming Languages

In this post I will share almost all of the programming language. If any questions come to your mind, you can post a comment below. And if you liked my post so you do not forget to subscribe to my Blog.

List of Programming Languages

1. 4th Dimension/4D
2. ABAP
3. ABC
4. ActionScript
5. Ada
6. Agilent VEE
7. Algol
8. Alice
9. Angelscript
10. Apex
11. APL
12. AppleScript
13. Arc
14. Arduino
15. ASP
16. AspectJ
17. Assembly
18. ATLAS
19. Augeas
20. AutoHotkey
21. AutoIt
22. AutoLISP
23. Automator
24. Avenue
25. Awk
26. Bash
27. (Visual) Basic
28. bc
29. BCPL
30. BETA
31. BlitzMax
32. Boo
33. Bourne Shell
34. Bro
35. C
36. C Shell
37. C#
38. C++
39. C++/CLI
40. C-Omega
41. Caml
42. Ceylon
43. CFML
44. cg
45. Ch
46. CHILL
47. CIL
48. CL (OS/400)
49. Clarion
50. Clean
51. Clipper
52. Clojure
53. CLU
54. COBOL
55. Cobra
56. CoffeeScript
57. ColdFusion
58. COMAL
59. Common Lisp
60. Coq
61. cT
62. Curl
63. D
64. Dart
65. DCL
66. DCPU-16 ASM
67. Delphi/Object Pascal
68. DiBOL
69. Dylan
70. E
71. eC
72. Ecl
73. ECMAScript
74. EGL
75. Eiffel
76. Elixir
77. Emacs Lisp
78. Erlang
79. Etoys
80. Euphoria
81. EXEC
82. F#
83. Factor
84. Falcon
85. Fancy
86. Fantom
87. Felix
88. Forth
89. Fortran
90. Fortress
91. (Visual) FoxPro
92. Gambas
93. GNU Octave
94. Go
95. Google AppsScript
96. Gosu
97. Groovy
98. Haskell
99. haXe
100. Heron
101. HPL
102. HyperTalk
103. Icon
104. IDL
105. Inform
106. Informix-4GL
107. INTERCAL
108. Io
109. Ioke
110. J
111. J#
112. JADE
113. Java
114. Java FX Script
115. JavaScript
116. JScript
117. JScript.NET
118. Julia
119. Korn Shell
120. Kotlin
121. LabVIEW
122. Ladder Logic
123. Lasso
124. Limbo
125. Lingo
126. Lisp
127. Logo
128. Logtalk
129. LotusScript
130. LPC
131. Lua
132. Lustre
133. M4
134. MAD
135. Magic
136. Magik
137. Malbolge
138. MANTIS
139. Maple
140. Mathematica
141. MATLAB
142. Max/MSP
143. MAXScript
144. MEL
145. Mercury
146. Mirah
147. Miva
148. ML
149. Monkey
150. Modula-2
151. Modula-3
152. MOO
153. Moto
154. MS-DOS Batch
155. MUMPS
156. NATURAL
157. Nemerle
158. Nimrod
159. NQC
160. NSIS
161. Nu
162. NXT-G
163. Oberon
164. Object Rexx
165. Objective-C
166. Objective-J
167. OCaml
168. Occam
169. ooc
170. Opa
171. OpenCL
172. OpenEdge ABL
173. OPL
174. Oz
175. Paradox
176. Parrot
177. Pascal
178. Perl
179. PHP
180. Pike
181. PILOT
182. PL/I
183. PL/SQL
184. Pliant
185. PostScript
186. POV-Ray
187. PowerBasic
188. PowerScript
189. PowerShell
190. Processing
191. Prolog
192. Puppet
193. Pure Data
194. Python
195. Q
196. R
197. Racket
198. REALBasic
199. REBOL
200. Revolution
201. REXX
202. RPG (OS/400)
203. Ruby
204. Rust
205. S
206. S-PLUS
207. SAS
208. Sather
209. Scala
210. Scheme
211. Scilab
212. Scratch
213. sed
214. Seed7
215. Self
216. Shell
217. SIGNAL
218. Simula
219. Simulink
220. Slate
221. Smalltalk
222. Smarty
223. SPARK
224. SPSS
225. SQR
226. Squeak
227. Squirrel
228. Standard ML
229. Suneido
230. SuperCollider
231. TACL
232. Tcl
233. Tex
234. thinBasic
235. TOM
236. Transact-SQL
237. Turing
238. TypeScript
239. Vala/Genie
240. VBScript
241. Verilog
242. VHDL
243. VimL
244. Visual Basic .NET
245. WebDNA
246. Whitespace
247. X10
248. xBase
249. XBase++
250. Xen
251. XPL
252. XSLT
253. XQuery
254. yacc
255. Yorick
256. Z shell

Read More

Data Types in C :Langauge

Data Types in C :

"Data type can be defined as the type of data of variable or constant store."
When we use a variable in a program then we have to mention the type of data. This can be handled using data type in C.
Followings are the most commonly used data types in C.

Keyword	Format Specifier	Size	Data Range
char	%c	1 Byte	-128 to +127
unsigned char	<-- -- >	8 Bytes	0 to 255
int	%d	2 Bytes	-32768 to +32767
long int	%ld	4 Bytes	-231 to +231
unsigned int	%u	2 Bytes	0 to 65535
float	%f	4 Bytes	-3.4e38 to +3.4e38
double	%lf	8 Bytes	-1.7e38 to +1.7e38
long double	%Lf	12-16 Bytes	-3.4e38 to +3.4e38

* QUALIFIER :
When qualifier is applied to the data type then it changes its size or its size.
Size qualifiers : short, long
Sign qualifiers : signed, unsigned


* ENUM DATA TYPE :
This is an user defined data type having finite set of enumeration constants. The keyword 'enum' is used to create enumerated data type.
Syntax:
enum [data_type] {const1, const2, ...., const n};


Example:
enum mca(software, web, seo);


* TYPEDEF :
It is used to create new data type. But it is commonly used to change existing data type with another name.
Syntax:
typedef [data_type] synonym;


OR


typedef [data_type] new_data_type;


Example:
typedef int integer;
integer rno;




C has a concept of 'data types' which are used to define a variable before its use. The definition of a variable will assign storage for the variable and define the type of data that will be held in the location.
The value of a variable can be changed any time.
C has the following basic built-in datatypes.

• int
• float
• double
• char

Please note that there is not a boolean data type. C does not have the traditional view about logical comparison, but thats another story.

int - data type
int is used to define integer numbers.
    {
        int Count;
        Count = 5;
    }

float - data type
float is used to define floating point numbers.

    {
        float Miles;
        Miles = 5.6;
    }


double - data type
double is used to define BIG floating point numbers. It reserves twice the storage for the number. On PCs this is likely to be 8 bytes.

    {
        double Atoms;
        Atoms = 2500000;
    }


char - data type
char defines characters.

    {
        char Letter;
        Letter = 'x';
    }


Modifiers
The data types explained above have the following modifiers.
• short
• long
• signed
• unsigned


The modifiers define the amount of storage allocated to the variable. The amount of storage allocated is not cast in stone. ANSI has the following rules:

        short int <=    int <= long int
            float <= double <= long double

What this means is that a 'short int' should assign less than or the same amount of storage as an 'int' and the 'int' should be less or the same bytes than a 'long int'. What this means in the real world is:
 

Type Bytes             Range ---------------------------------------------------------------------

short int  2          -32,768 -> +32,767          (32kb)    unsigned short int  2                0 -> +65,535          (64Kb)          unsigned int  4                0 -> +4,294,967,295   ( 4Gb)                   int  4   -2,147,483,648 -> +2,147,483,647   ( 2Gb)              long int  4   -2,147,483,648 -> +2,147,483,647   ( 2Gb)           signed char  1             -128 -> +127         unsigned char  1                0 -> +255                 float  4                double  8            long double 12

These figures only apply to todays generation of PCs. Mainframes and midrange machines could use different figures, but would still comply with the rule above.
You can find out how much storage is allocated to a data type by using the sizeof operator discussed in Operator Types Session.
Here is an example to check size of memory taken by various datatypes.

int main() {   printf("sizeof(char) == %d\n", sizeof(char));   printf("sizeof(short) == %d\n", sizeof(short));   printf("sizeof(int) == %d\n", sizeof(int));   printf("sizeof(long) == %d\n", sizeof(long));   printf("sizeof(float) == %d\n", sizeof(float));   printf("sizeof(double) == %d\n", sizeof(double));   printf("sizeof(long double) == %d\n", sizeof(long double));   printf("sizeof(long long) == %d\n", sizeof(long long));   return 0; }

Qualifiers

A type qualifier is used to refine the declaration of a variable, a function, and parameters, by specifying whether:
• The value of a variable can be changed.
• The value of a variable must always be read from memory rather than from a register

Standard C language recognizes the following two qualifiers:
• const
• volatile

The const qualifier is used to tell C that the variable value can not change after initialisation.
const float pi=3.14159;
Now pi cannot be changed at a later time within the program.
Another way to define constants is with the #define preprocessor which has the advantage that it does not use any storage
The volatile qualifier declares a data type that can have its value changed in ways outside the control or detection of the compiler (such as a variable updated by the system clock or by another program). This prevents the compiler from optimizing code referring to the object by storing the object's value in a register and re-reading it from there, rather than from memory, where it may have changed. You will use this qualifier once you will become expert in "C". So for now just proceed.


What are Arrays:
We have seen all baisc data types. In C language it is possible to make arrays whose elements are basic types. Thus we can make an array of 10 integers with the declaration.
int x[10];

The square brackets mean subscripting; parentheses are used only for function references. Array indexes begin at zero, so the elements of x are:
Thus Array are special type of variables which can be used to store multiple values of same data type. Those values are stored and accessed using subscript or index.
Arrays occupy consecutive memory slots in the computer's memory.

x[0], x[1], x[2], ..., x[9]

If an array has n elements, the largest subscript is n-1.
Multiple-dimension arrays are provided. The declaration and use look like:

      int name[10] [20];
      n = name[i+j] [1] + name[k] [2];

Subscripts can be arbitrary integer expressions. Multi-dimension arrays are stored by row so the rightmost subscript varies fastest. In above example name has 10 rows and 20 columns.
Same way, arrays can be defined for any data type. Text is usually kept as an array of characters. By convention in C, the last character in a character array should be a `\0' because most programs that manipulate character arrays expect it. For example, printf uses the `\0' to detect the end of a character array when printing it out with a `%s'.

Here is a program which reads a line, stores it in a buffer, and prints its length (excluding the newline at the end).

       main( ) {
               int n, c;
               char line[100];
               n = 0;
               while( (c=getchar( )) != '\n' ) {
                       if( n < 100 )
                               line[n] = c;
                       n++;
               }
               printf("length = %d\n", n);
       }


Array Initialization
• As with other declarations, array declarations can include an optional initialization
• Scalar variables are initialized with a single value
• Arrays are initialized with a list of values
• The list is enclosed in curly braces
int array [8] = {2, 4, 6, 8, 10, 12, 14, 16};

The number of initializers cannot be more than the number of elements in the array but it can be less in which case, the remaining elements are initialized to 0.if you like, the array size can be inferred from the number of initializers by leaving the square brackets empty so these are identical declarations:

int array1 [8] = {2, 4, 6, 8, 10, 12, 14, 16};
int array2 [] = {2, 4, 6, 8, 10, 12, 14, 16};
An array of characters ie string can be initialized as follows:
char string[10] = "Hello";

Read More

All Keyword in C Language

There are 32 keywords that, when combined with the formal C 
syntax, form the C language as defined by the ANSI C. Note that
 5 new keywords have been introduced into the new C9X standard
 (read draft) - these are not covered here yet.

All keywords use lowercase letters. In C, uppercase and lowercase
 are different, for instance, else is a keyword, ELSE is not a keyword 
though.An alphabetical summary of each of the keywords is as
 follows:

auto	double	int	struct
break	else	long	switch
case	enum	register	typedef
char	extern	return	union
const	float	short	unsigned
continue	for	signed	void
default	goto	sizeof	volatile
do	if	static	while

auto
auto is used to create temporary variables that are created upon entry into a 
block of and destroyed upon exit. For example:

#include <stdio.h>
#include <conio.h>

int main(void)
{

    for(; ;)
    {

        if (getche() == 'a')
        {
            auto int t;

            for (t=0; t<'a'; t++)
                printf("%d ", t);

            break;
          }

     }

        return 0;

}

In this example, the variable t is created only if the user strikes an a. Outside
 the if block, t is completely unknown, and any reference to it would generate a
 comile-time syntax error. The use of auto is completely optional since all local
 variables are auto by default.

In many cases it is used simply to make the program more readable. That is 
because if you see that a variable or string literal has an auto keyword in front
 of it, you can tell that the variable or string literal is a local variable or string 
literal and not a global one. It can be used to simply tell the reader whether 
the variable or string literal is local or global - the compiler doesn't normally 
use it.

break
break is used to exit from a do, for, or while loop, bypassing the normal loop 
condition. It is also used to exit from a switch statement. An example of break
 in a loop is shown here:

while (x < 100)
{
    x = get_new_x();
    if (kbhit()) break;     /* key hit on keyboard */
    process(x);
}

Here, if a key is pressed, the loop will terminate no matter what the value of x
 is. In a switch statement, break effectively keeps program execution from
 "falling through" to the next case. (refer to the lesson covering the switch 
statement for details).

case
case is covered in conjunction with switch.

char
char is a data type used to declare character variables. For example, to declare
 ch to be character type, you would write:

char ch;

In C, a character is one byte long. This means if you were to assign a string to
 a variable type char, than only the first character will be assigned and the
 remaining characters will not be used.

const
The const modifier tells the compiler that the contents of a variable cannot be 
changed. It is also used to prevent a function from modifying the object pointed
 to by one of its arguments. To declare a variable as a constant use:

const int pass = 65;

continue
continue is used to bypass portions of code in a loop and forces the conditional 
expression to be evaluated. For example, the following while loop will simply
 read characters from the keyboard until an M or F gender is specified:

#include <stdio.h>
#include <conio.h>
#include <stdio.h>
#include <ctype.h>

int main(void)
{
    char gender;

    while (gender = getche())
    {

        gender = toupper(gender);

        if (gender != 'M' && gender != 'F' )
        {
            printf("Incorrect gender, please type again\n");
            continue;
        }

    break;

    }

    return 0;
}

default
default is used in the switch statement to signal a default block of code to be 
executed if no matches are found in the switch. See the switch section for more
 info.

do
The do loop is one of three loop constructs available in C. The general form of 
the do loop is

do
{
     statement block
} while (condition);

If only one statement is repeated, the braces are not necessary, but they add 
clarity to the statement. he do loop repeats as long as the condition is true. 
The do loop is the only loop in C that will always have at least one iteration 
because the condition is tested at the bottom of the loop. A common use of 
the do loop is to read disk files. This code will read a fine until and 
EOF (end of file) is encountered.

do
{
    ch = getc(fp);
    if (!eof(fp)) printf("%c", ch);
while (!eof(fp));

double
double is a data type specifier used to declare double-precision floating-point
 variables. double is the data type specifier needed when a value of the 
mathematical equivalent (scientific notation) of standard form, needs to be
 declared. To declare d to be of type double you would write the following
 statement:

double d;

else
see the if section.

enum
The enum type specifier is used to create enumeration types. An enumeration
 is simply a list of named integer constants. For example, the following code 
declares an enumeration called color that consists of three constants:
red, green, and yellow:

#include <stdio.h>

enum color {red, green, yellow};
enum color c;

int main(void)
{
    c = red;

    if (c==red) printf("is red\n");

    return 0;

}

extern
The extern data type modifier tells the compiler that a variable is defined 
elsewhere in the program. This is often used in conjunction with separately
 compiled files that share the same global data and are linked together.
 In essence, it notifies the compiler of a variable without redefining it.

As an example, if first were declared in another file as an integer, the following 
declaration would be used in subsequent files:

extern int first;

float
float is a data type specifier used to declare floating point variables. To declare
f to be of type float you would write:

float f;

for
The for loop allows automatic initialization of instrumentation of a counter 
variable. The general form is

for (initialization; condition; increment)
{
    statement block
}

If the statement block is only one statement, the braces are not necessary. 
Although the for allows a number of variations, generally the initialization is 
used to set a counter variable to its starting value. The condition is generally a 
relational statement that checks the counter variable against a termination 
value, and the increment increments (or decrements) the counter value. 
The loop repeats until the condition becomes false.

The following code will print hello ten times:

for (t=0; t<10; t++) printf("Hello\n");

goto
The goto causes program execution to jump to the label specified in the goto
statement. The general form of the goto is

goto label;
..
..
..
label;

All labels must end in a colon and must not conflict with keywords or function 
names. Furthermore, a goto can branch only within the current function, and
 not from one function to another.

The following example will print the message right but not the message wrong:

goto lab1;
    printf("wrong");
labl1:
    printf("right");

if
The general form of the if statement is:

if (condition)
{
    statement block 1
}
else
{
    statement block 2
}

If single statements are used, the braces are not needed. The else is optional. 
The condition may be any expression. If that expression evaluates to any value
 other than 0, then statement block 1 will be executed; otherwise, if it exists, 
statement block 2 will be executed. The following code fragment can be used
 for keyboard input and to look for a 'q' which signifies "quit."

ch = getche();

if (ch == 'q')
{
    printf("Program Terminated");
    exit(0);
}
else proceed();

int
int is the type specifier used to declare integer variables. For example, to
 declare count as an integer you would write

int count;

long
long is a data type modifier used to declare long integer and long double 
variables. For example, to declare count as a long integer you would write

long int count;

register
The register modifier requests that a variable be stored in the way that allows
 the fastest possible access. In the case of characters or integers, this usually
 means a register to the CPU. To declare i to be a register integer, you would
 write:

register int i;

return
The return statement forces a return from a function and can be used to 
transfer a value back to the calling routine. For example, the following function
 returns the product of its two integer arguments.

int mul(int a, int b)
{
return a*b;
}

Keep in mind that as soon as return is encountered, the functions will return, 
skipping any other code in the function.

short
short is a data type modifier used to declare small integers. For example, 
to declare sh to be a short integer you would write

short int sh;

signed
The signed type modifier is most commonly used to specify a signed char 
data type.

sizeof
The sizeof keyword is a compile-time operator that returns the length of the
 variable or type it precedes. If it precedes a type, the type must be enclosed
 in parenthesis. For example:

printf("%d", sizeof(short int));

will print 2 for most C implementations.

The sizeof statement's principal use is in helping to generate portable code 
when that code depends on the size of the C built-in data types.

static
The static keyword is a data type modifier that causes the compiler to create 
permanent storage for the local variable that it precedes. This enables the 
specified variable to maintain its value between function calls. For example, 
to declarelast_time as static integer, you would write:

static int last_time;

static can also be used on global variables to limit their scope to the file in 
which they are declared.

struct
The struct statement is used to create aggregate data types, called structures
 that are made up of one or more members. The general form of a structure is:

struct struct-name
{
    type member1;
    type member2;
    ..
    ..
    ..
    type member N;
} variable-list;

The individual members are referenced using the dot or arrow operators.

switch
The switch statements is C multi-path branch statement. It is used to route 
execution in one of several ways. The general form of the statement is:

switch(int-expression)
{
    case constant1: statement-set 1;
        break;
    case constant2: statement-set 2;
        break;
    ..
    ..
    ..
    case constantN: statement-set N;
        break;
    default: default-statements;
}

Each statement-set may be one or many statements long. The default portion
 is optional. The expression controlling the switch and all case constants must
 be of integral or character types.

The switch works by checking the value of int-expression against the constants. As soon as a match is found, the set of statements is executed. If the break statement is omitted, execution will continue into the next case. You can think of the cases as labels. Execution will continue until a break statement is found or the switch ends. The following example can be used to process a menu selection:

ch = getche();

switch(ch)
{
    case 'e': enter();
        break;
    case '1': list();
        break;
    case 's': sort();
        break;
    case 'q' : exit(0);
        break;
    default: printf("Unknown Command\n");
        printf("Try Again\n");
}

typedef
The typedef statement allows you to create a new name for an existing data
 type. The general form of typedef is:

typedef type-specifier new-name;

For example, to use the word 'balance' in place of 'float', you would write

typedef float balance;

union
The union keyword creates an aggregate type in which two or more variables
 share the same memory location. The form of the declaration and the way a
 member is accessed are the same as for struct. The general form is:

union union-name
{
    type member1;
    type member2;
    ..
    ..
    ..
    type memberN;
} variable-list;

unsigned
The unsigned type modifier tells the compiler to create a variable that holds 
only unsigned (i.e., positive) values. For example, to declare big to be an
 unsigned integer you would write

unsigned int big;

void
The void type specifier is primarily used to declare void functions 
(functions that do not return values). It is also used to create void pointers 
(pointers to void) that are generic pointers capable of pointing to any type of 
object and to specify an empty paramater list.

volatile
The volatile modifier tells the compiler that a variable may have its constants 
altered in ways not explicitly defined by the program. Variables that are 
changed by the hardware, such as real-time clocks, interrupts, or other inputs 
are examples.

while
The while loop has the general form:

while(condition)
{
    statement block
}

If a single statement is the object of the while, the braces may be omitted. The
 loop will repeat as long as the condition is true. The while tests its condition at 
the top of the loops. Therefore, if the condition is false to begin with, 
the loop will not execute at all. The condition may be any expression. 
An example of a while follows. It reads characters until end-of-file is 
encountered.

t = 0;

while(!feof(fp))
{
    s[t] = getc(fp);
}

Read More