Prolog Programming Directory, Links. Development, Programmers, Programmer Reference, Resources @ eIT.in

Add Links: If you have a web site that you wish to include in this database, do let us know the details by sending a note about your URL to narsi@esource.in. We’ll quickly review the web site, and if found relevant, add it to the database. We look forward to web site owners and link exchange partners to submit URL. Thanks!

Looking for an outsourcing partner for software programming & development? Have you talked to us?

Other IT Web Sites from eIT.in

Content derived from Wikipedia article on PROLOG Programming Language

Prolog

From Wikipedia, the free encyclopedia

Prolog Paradigm: Logic programming

Appeared in: 1972

Major implementations: GNU Prolog, Quintus, SICStus, SWI-Prolog, YAP

Dialects: ISO Prolog, Edinburgh Prolog

Influenced: Visual Prolog, Mercury, Oz, Erlang, Strand

Prolog is a logic programming language. The name Prolog was chosen by Philippe Roussel as an abbreviation for "PROgrammation en LOGique”. It was created by Alain Colmerauer, Philippe Roussel and Robert Kowalski around 1972 as an alternative to the American-dominated Lisp programming languages. It is an attempt to make a programming language that enables the expression of logic instead of carefully specified instructions on the computer. In some ways Prolog is a subset of Planner, e.g., see Kowalski's early history of logic programming. The ideas in Planner were later further developed in the Scientific Community Metaphor.

Prolog is used in many artificial intelligence programs and in computational linguistics (especially natural language processing, which it was originally designed for). A lot of the research leading up to modern implementations of Prolog came from spin-off effects caused by the fifth generation computer systems project (FGCS) which chose to use a variant of Prolog named Kernel Language for their operating system (but this area of research is now actually almost defunct).

Prolog is based on first-order predicate calculus; however it is restricted to allow only Horn clauses. See Logic programming for a discussion of the relationship of Prolog to mathematical logic. Execution of a Prolog program is effectively an application of theorem proving by first-order resolution. Fundamental concepts are unification, tail recursion, and backtracking.

Contents

1 Data types

1.1 Atoms

1.2 Numbers

1.3 Variables

1.4 Terms

1.5 Lists

1.6 Strings

2 Facts

3 Rules

4 Evaluation

4.1 Negation

5 Execution

6 Parsing

6.1 Parser example

7 Examples

7.1 QuickSort

7.2 Towers of Hanoi

7.3 Computer Algebra

8 Comparison of Implementations

9 Extensions

10 External links

10.1 Implementations

10.2 Tutorial introductions

10.3 Advanced level programming

10.4 Conferences

10.5 Other resources

11 References

Data types

Prolog does not employ data types in the way common programming languages usually do. We may rather speak about Prolog lexical elements instead of data types.

Atoms

The text constants are introduced by means of atoms. An atom is a sequence consisting of letters, numbers and underscores, which begins with a lower-case letter. Usually, if a non-alphanumeric atom is needed, it is surrounded with apostrophes (e.g. 'an atom containing spaces').

Numbers

Most Prolog implementations do not distinguish integers from real numbers.

Variables

Variables are denoted by a string consisting of letters, numbers and underscore characters, and beginning with an upper-case letter or underscore. In the Prolog environment, a variable is not a container that can be assigned to (unlike imperative programming languages). Its behaviour is closer to a pattern, which is increasingly specified by unification.

The so called anonymous variable (explained below), a wildcard which means 'any variable', is written as a single underscore (_).

Terms

Terms are the only way Prolog can represent complex data. A term consists of a head, also called functor (which must be an atom) and parameters (unrestricted types) listed within parentheses and separated by commas. The number of parameters, the so called arity of term, is significant. A term is identified by its head and arity, usually written as functor/arity.

Lists

A list isn't a standalone data type, because it is defined by a recursive construction (using term '.'/2):

atom [] is an empty list

if T is a list and H is an element, then the term '.'(H, T) is a list.

The first element, called the head, is H, which is followed by the contents of the rest of the list, designated T or tail. The list [1, 2, 3] would be represented internally as '.'(1, '.'(2, '.'(3, []))). A syntactic shortcut is [H | T], which is mostly used to construct rules. The entirety of a list can be processed by processing the first element, and then the rest of the list, in a recursive manner.

For programmer's convenience, the lists can be constructed and deconstructed in a variety of ways.

Element enumeration: [abc, 1, f(x), Y, g(A,rst)]

Prepending single element: [abc | L1]

Prepending multiple elements: [abc, 1, f(x) | L2]

Term expansion: '.'(abc, '.'(1, '.'(f(x), '.'(Y, '.'(g(A,rst), [])))))

The append predicate

Strings

Strings are usually written as a sequence of characters surrounded by quotes. They are often internally represented as lists of character codes, generally in the local character encoding or Unicode if the system supports Unicode. ISO Prolog also allows strings to be represented as a list of one-character atoms.

Facts

Programming in Prolog is very different from programming in a procedural language. In Prolog you supply a database of facts and rules; you can then perform queries on the database. The basic unit of Prolog is the predicate, which is defined to be true. A predicate consists of a head and a number of arguments. For example:

cat(tom).

This enters into the database the fact that 'tom' is a 'cat'. More formally, 'cat' is the head, and 'tom' is the single argument. Here are some sample queries you could ask a Prolog interpreter basing on this fact:

is tom a cat?

?- cat(tom).

yes.

what things are cats?

?- cat(X).

X = tom;

yes.

Predicates are usually defined to express some fact the program knows about the world. In most of the cases, the usage of predicates requires a certain convention. Thus, which version of the two below would signify that Bob is the father of Sally?

father(sally,bob).

father(bob,sally).

In both cases 'father' is the head and 'sally' and 'bob' are arguments. However in the first case, Sally comes first in the argument list, and in the second, Bob comes first (the order in the argument list matters). The first case is an example of a definition in Verb Subject Object order, and the second of Verb Object Subject order. Since Prolog does not understand English, both versions are fine so far as it is concerned; however it is good programming style to stick to either convention during the writing of a single program, in order to avoid writing something like

father(bob,sally).

father(jessica,james).

Some predicates are built into the language, and allow a Prolog program to perform routine activities (such as input/output, using graphics and otherwise communicating with the operating system). For example, the predicate write can be used for output to the screen. Thus,

write('Hello').

will display the word 'Hello' on the screen.

Rules

The second type of statement in Prolog is the rule, also called "clause". An example of a rule is

light(on) :- switch(on).

The ":-" means "if"; this rule means light(on) is true if switch(on) is true. Rules can also make use of variables; variables begin with capital letters while constants begin with lower case letters. For example,

father(X,Y) :- parent(X,Y),male(X).

This means "if someone is a parent of someone and he's male, he is a father". The antecedent and consequent are in reverse order to that normally found in logic: the consequent is written first and called the head of the rule, the antecedent is called the body. Conjunction (and) is written as a comma (","), while disjunction (or) is written as semi-colon (";"). It is also possible to place multiple predicates in a body which are joined with disjunction, for example:

a :- b;c;d.

which is simply equivalent to three separate rules:

a :- b.

a :- c.

a :- d.

What is not allowed are rules like this:

a;b :- c.

That is, "if c then a or b". This is because of the restriction to Horn clauses.

Evaluation

When the interpreter is given a query, it tries to find facts that match the query. If no outright facts are available, it attempts to satisfy all rules that have the fact as a conclusion. For example:

sibling(X,Y) :- parent(Z,X), parent(Z,Y).

parent(X,Y) :- father(X,Y).

parent(X,Y) :- mother(X,Y).

mother(trude, sally).

father(tom, sally).

father(tom, erica).

father(mike, tom).

This results in the following query being evaluated as true:

?- sibling(sally, erica).

yes.

The interpreter arrives at this result at matching the rule sibling(X,Y) by binding sally to X and erica to Y. This means the query can be expanded to parent(Z,sally), parent(Z,erica). Matching this conjunction is done by looking at all possible parents of sally. However, parent(trude,sally) doesn't lead to a viable solution, because if trude is substituted for Z, parent(trude,erica) would have to be true, and no such fact (or any rule that can satisfy this) is present. So instead, tom is substituted for Z, and erica and sally turn out to be siblings none the less. The code

parent(X,Y) :- father(X,Y).

might seem suspicious. After all, not every parent is a father. But actually this code means that any father is a parent. To infer that all fathers are male, you'd need to code

male(X) :- father(X,_).

which simply doesn't care whoever the child is (the underscore is an anonymous variable). Note that this example has a bug. It will also evaluate sibling(sally, sally) to true, as it can bind X=sally, Y=sally, as of course they both share the same parent.

Negation

Typically, a query is evaluated to be false by merit of not finding any positive rules or facts that support the statement. This is called the closed world assumption; it is assumed that everything worth knowing is in the database, so there is no outside world that might contain heretofore unknown evidence. In other words, if a fact is not known to be true (or false), it is assumed to be false.

A rule such as

legal(X) :- \+ illegal(X).

can only be evaluated by exhaustively searching for all things illegal and comparing them to X, and if no illegal fact can be found to be the same as X, X is legal. This is called negation as failure. The \+/1 prefix operator used above implements negation as failure in ISO Prolog compilers.

Negation can be used to correct the sibling/2 term above, to make it return false for sibling(sally,sally).

sibling(X,Y) :- parent(Z,X), parent(Z,Y), \+ X=Y.

Here the negation operator adds a restriction that it is not enough for X and Y to share the same parent, they must not refer to the same entity. One of the challenges in Prolog coding is writing clauses that are valid in all possible circumstances, and this is one example.

Negation can also be done through the keyword 'not'. The above code could be rewritten

sibling(X,Y) :- parent(Z,X), parent(Z,Y), not(X=Y).

Execution

Prolog is a logical language, so in theory the programmer shouldn't care about how it executes. However, sometimes it is prudent to take into account how the inference algorithm works, to prevent a Prolog program from running for an unnecessarily long time.

For example, we can write code to count the number of elements in a list.

elems([],0).

elems([H|T], X) :- elems(T, Y), X is Y + 1.

This simply says: If the list is empty, the number of elements is zero. If the list is non-empty, then X is one higher than Y, which is the number of elements in the remainder of the list without the first element.

In this case, there is a clear distinction between the cases in the rules' antecedent. But consider the case where you need to decide whether to keep gambling in a casino:

gamble(X) :- gotmoney(X).

gamble(X) :- gotcredit(X), \+ gotmoney(X).

If you have money, you keep gambling. If you've lost it all, you'll need to borrow money, or else no more gambling. gotmoney(X) might be a very costly function - for example, it might access your internet banking account to check your balance, which takes time. However, the same goes for gotcredit(X).

In theory, Prolog implementations might evaluate these rules out of order, so you might as well have written:

gamble(X) :- gotcredit(X), \+ gotmoney(X).

gamble(X) :- gotmoney(X).

This is fine, because the two options exclude each other. However, checking whether you can get a loan is not necessary if you know you have money. So in practice, Prolog implementations will check the uppermost rule first (in fact, most Prologs will always try the rules in order from the uppermost to the lowermost). You can use the cut operator to tell the interpreter to skip the second option if the first suffices. For example:

gamble(X) :- gotmoney(X),!.

gamble(X) :- gotcredit(X), \+ gotmoney(X).

This is called a green cut operator. The ! simply tells the interpreter to stop looking for alternatives. But you'll notice that if you need money it will need to check the second rule, and it will. Checking for gotmoney in the second rule is pretty useless since you already know you don't have any, otherwise the second rule wouldn't be evaluated in the first place. So you can change the code to

gamble(X) :- gotmoney(X),!.

gamble(X) :- gotcredit(X).

This is called a red cut operator, because it is dangerous to do this. You now depend on the proper placement of the cut operator and the order of the rules to determine their logical meaning. Cut-and-paste accidents lurk in dark corners. If the rules got mixed up, you might now max out your credit card before spending your cash.

Parsing

Prolog has a built in mechanism for parsing context-free grammar. Using the arrow notation one can easily define a parser in prolog that evaluates the grammatical correctness in a formal language, e.g. a programming language. The input string should first be tokenized into tokens using the Prolog list, e.g.

x = 2

[x, =, 2]

To evaluate the list we could use ordinary Prolog list manipulation. We use a binary predicate which takes the input list as its first argument and what ever rest we get after the parse is complete (the rest should be [] if parse was successful). The following example shows how it can be done:

statement(A,B) :- id(A,C), assign_op(C,D), digit(D,B).

id([x|X],X).

assign_op([=|X],X).

digit([2|X],X).

The nestling of list tails can be automated using the built in parsing mechanism, also known as arrow notation.

statement --> id, assign_op, digit.

Parser example

A larger example will show the potential of using Prolog in parsing.

Given the sentence expressed in BNF:

<stat_part> ::= <statement> | <stat_part> <statement>

<statement> ::= <id> = <expression> ;

<id> ::= a | b

<digit> ::= 0..9

<operator> ::= + | - | *

This can be written in Prolog using the arrow notation (assuming the input like [a, =, 3, *, b, ;, b, =, 0, ;] etc.):

sentence --> stat_part.

stat_part --> statement ; stat_part, statement.

statement --> id, [=], expression, [;].

expression --> operand ; operand, operator, expression.

operand --> id ; digit.

id --> [a] ; [b].

digit --> [D], {D>=0, D=<9}.

operator --> [+] ; [-] ; [*].

Examples

Here follows some program examples written in ISO-PROLOG.

QuickSort

split(H, [A|X], [A|Y], Z) :-

order(A, H), split(H, X, Y, Z).

split(H, [A|X], Y, [A|Z]) :-

not(order(A, H)), split(H, X, Y, Z).

split(_, [], [], []).

quicksort([], X, X).

quicksort([H|T], S, X) :-

split(H, T, A, B),

quicksort(A, S, [H|Y]),

quicksort(B, Y, X).

Towers of Hanoi

This example simulates the Towers of Hanoi problem of moving discs from a left pole to a right pole.

hanoi(N) :- move(N, left, right, centre).

move(0, _, _, _) :- !.

move(N, A, B, C) :-

M is N-1,

move(M, A, C, B),

inform(A, B),

move(M, C, B, A).

inform(X, Y) :-

write('move a disc from the '),

write(X),

write(' pole to the '),

write(Y),

write(' pole'),

nl.

Computer Algebra

This example demonstrates the power and ease-of-use of symbolic manipulation in Prolog.

/* Derivation Definition */

d(X,X,1) :- !. /* d x dx = 1 */

d(C,X,0) :- atomic(C). /* d c dx = 0 */

d(-U,X,-A) :- d(U,X,A). /* d -u dx = - d u dx */

d(U+V,X,A+B) :- d(U,X,A), d(V,X,B). /* d u+v dx = d u dx + d v dx */

d(U-V,X,A-B) :- d(U,X,A), d(V,X,B). /* d u-v dx = d u dx - d v dx */

d(C*U,X,C*A) :- atomic(C), C \= X, d(U,X,A), !. /* d c*u dx = c*d u dx */

d(U*V,X,B*U+A*V) :- d(U,X,A), d(V,X,B). /* d u*v dx = u*d v dx + v*d u dx */

d(U/V,X,A) :- d(U*V^(-1),X,A). /* d u/v dx = d (u*v)^-1 dx */

d(U^C,X,C*U^(C-1)*W) :- atomic(C), C \= X, d(U,X,W). /* d u^c dx = c*u^(c-1)*d u dx */

d(log(U),X,A*U^(-1)) :- d(U,X,A). /* d ln(u) dx = u^-1 * d u dx */

/* Integral Definition */

i(0,X,0) :- !. /* Int 0 dx = 0 */

i(X,X,(X*X)/2) :- !. /* Int X dx = (X^2)/2 */

i(C,X,C*X) :- atomic(C). /* Int c dx = c*x */

i(-U,X,-A) :- i(U,X,A). /* Int -U dx = - Int U dx */

i(U+V,X,A+B) :- i(U,X,A), i(V,X,B). /* Int U+V dx = Int U dx + Int V dx */

i(U-V,X,A-B) :- i(U,X,A), i(V,X,B). /* Int U-V dx = Int U dx - Int V dx */

i(C*U,X,C*A) :- atomic(C), C \= X, i(U,X,A), !. /* Int cU dx = c (Int U dx) */

i(X^C,X,(X^(C+1))/(C+1)) :- atomic(C), !. /* Int x^c dx = x^(c+1)/(c+1) */

i(U,V,U*V-A) :- d(V,U,A), !. /* Int u dv = u*v - Int v du */

/* Simplification Rules */

s(+,X,0,X). /* x + 0 = x */

s(+,0,X,X). /* 0 + x = x */

s(+,X,Y,X+Y). /* x + y = x + y */

s(+,X,Y,Z) :- integer(X), integer(Y), Z is X+Y. /* x + y = z <- Calculate */

s(*,_,0,0). /* anything * 0 = 0 */

s(*,0,_,0). /* 0 * anything = 0 */

s(*,1,X,X). /* 1 * x = x */

s(*,X,1,X). /* x * 1 = x */

s(*,X,Y,X*Y). /* x * y = x * y */

s(*,X*Y,W,X*Z) :- integer(Y), integer(W), Z is Y*W.

s(*,X,Y,Z) :- integer(X), integer(Y), Z is X*Y. /* x * y = z <- Calculate */

/* Simplification Definition */

simp(E,E) :- atomic(E), !.

simp(E,F) :- E =.. [Op, La, Ra], simp(La,X), simp(Ra,Y), s(Op,X,Y,F).

Comparison of Implementations

Platform Features Toolkit Prolog Mechanics

Name OS Licence Native Graphics Unicode Object Oriented Native OS Control Stand Alone Executable C Interface* Java Interface* Interactive Interpreter Debugger Code Profiler Syntax

DOS-PROLOG MS-DOS Shareware Yes Yes Yes Yes Yes Edinburgh Prolog

Open Prolog Mac OS Freeware Yes

Ciao Prolog Unix, Windows GPL Yes Yes Yes Yes Yes ISO-Prolog

GNU Prolog Unix, Windows GPL Yes Yes Yes Yes Yes ISO-Prolog

Visual Prolog Windows Freeware, Commercial Yes Yes Yes Yes Yes Yes Yes

SWI-Prolog Unix, Windows, Mac OS X LGPL Yes Yes Yes Yes Yes Yes Yes Yes ISO-Prolog, Edinburgh Prolog

tuProlog JVM LGPL Yes Yes Yes Yes Yes Yes ISO-Prolog

*C/Java interface can also be used for graphics and OS control.

Extensions

HiLog and λProlog extend Prolog with higher-order programming features.

F-logic extends Prolog with frames/objects for knowledge representation.

Visual Prolog, also formerly known as PDC Prolog and Turbo Prolog. Visual Prolog is a strongly-typed object-oriented dialect of Prolog, which is considerably different than standard Prolog. As Turbo Prolog it was marketed by Borland, but it is now developed and marketed by the Danish firm PDC (Prolog Development Center) that originally produced it.

OW Prolog has been created in order to answer Prolog's lack of graphics and interface.

InterProlog, a programming library bridge between Java and Prolog, implementing bi-directional predicate/method calling between both languages. Java objects can be mapped into Prolog terms and vice-versa. Allows the development of GUIs and other functionality in Java while leaving logic processing in the Prolog layer. Supports XSB, SWI-Prolog and YAP.

Prova provides native syntax integration with Java, agent messaging and reaction rules. Prova positions itself as a rule-based scripting (RBS) system for middleware. The language breaks new ground in combining imperative and declarative programming.

Logtalk is an open source object-oriented extension to the Prolog programming language. Integrating logic programming with object-oriented and event-driven programming, it is compatible with most Prolog compilers. It supports both prototypes and classes. In addition, it supports component-based programming through category-based composition.

Datalog is actually a subset of PROLOG. It is limited to relationships that may be stratified such that solutions on a large knowledge base return in finite time.

External links

Wikibooks Programming has more about this subject:

Prolog

Implementations

WIN Prolog by Logic Programming Associates

Open Prolog, an Apple Mac implementation.

Ciao Prolog, open source under GPL and LGPL

GNU Prolog, open source under GPL

YAP Prolog, open source under Artistic License

Visual Prolog, formerly known as PDC Prolog and Turbo Prolog

SWI-Prolog, open source under LGPL

AI::Prolog, a perl module that comes with a prolog command-line interpreter

SICStus Prolog

ECLiPSe, ECLiPSe Prolog

Amzi! Prolog

B-Prolog

tuProlog, open source under LGPL

XSB, open source under LGPL

MINERVA - commercial ISO-Prolog compiler in 100% Java

Trinc Prolog

Strawberry Prolog, specially designed for education

hProlog

ilProlog, a component of the DMax software stack

CxProlog

NanoProlog, a WAM based minimal Prolog system

BinProlog

Quintus Prolog, the industrial standard implementation

Allegro Prolog, an implementation within Allegro Common Lisp

ALS Prolog

W-Prolog, a Prolog interpreter in a Java applet.

EZY Prolog, a Prolog interpreter and IDE for Windows

GraphTalk, a proprietary WAM based implementation with object extensions, designed for building of information systems.

The Poplog system implements a version of Prolog, with POP-11, and optionally Common Lisp (CL), and Standard ML (SML), allowing mixed language programming. For all, the implementation language is POP-11, which is compiled incrementally. It also has an integrated Emacs-like editor that communicates with the compiler.

REBOL Prolog, prolog.r at Rebol.org

Tutorial introductions

Prolog Tutorial by J.R.Fisher

Visual Prolog Tutorial

Runnable examples by Lloyd Allison

Visual Prolog Examples

Logic Programming and Prolog (2ed) by Ulf Nilsson and Jan Maluszynski

Prolog Programming A First Course by Paul Brna

Adventure in Prolog, online book by Amzi! Inc.

On-line guide to Prolog Programming by Roman Bartak

Prolog minibook by Faiz ul haque Zeya

Learn Prolog Now! by Patrick Blackburn, Johan Bos and Kristina Striegnitz

Prolog and Logic Programming by Dr Peter Hancox

Advanced level programming

Richard O'Keefe, The Craft of Prolog, ISBN 0-262-15039-5.

Building Expert Systems in Prolog, online book by Amzi! Inc.

Conferences

ICLP International Conference on Logic Programming

INAP International Conference on Declarative Programming and Knowledge Management (former Intl. Conf. on Applications of Prolog)

Other resources

comp.lang.prolog FAQ

Prolog: The ISO standard

Prolog Development Center

References

Michael A. Covington, Donald Nute, Andre Vellino, Prolog Programming in Depth , 1996, ISBN 013138645X

Michael A. Covington, Natural Language Processing for Prolog Programmers, 1994, ISBN 0-13-629213-5.

Leon Sterling and Ehud Shapiro, The Art of Prolog: Advanced Programming Techniques, 1994, ISBN 0-262-19338-8

Ivan Bratko, PROLOG Programming for Artificial Intelligence, 2000, ISBN 0-201-40375-7.

Robert Kowalski, The Early Years of Logic Programming, CACM January 1988.

ISO/IEC 13211: Information technology — Programming languages — Prolog. International Organization for Standardization, Geneva.

Alain Colmerauer and Philippe Roussel, The birth of Prolog, in The second ACM SIGPLAN conference on History of programming languages, p. 37-52, 1992.

Preceding: Planner

Subsequent: HiLog, λProlog, Visual Prolog, OW Prolog, InterProlog, SWI-Prolog, Prova, Logtalk, Datalog, Oz

Retrieved from http://en.wikipedia.org/wiki/Prolog

End of Wikipedia content, http://en.wikipedia.org/wiki/Prolog

Web Resources for Prolog Programming Language

More eIT.in References

o Programming Languages

§ The A-Z of Programming Languages

§ A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z

§ P

· Pascal

· Perl

· PHP Programming

· Phantom

· Pike

· PiXCL

· PL/B

· PL/I

· Plankalkül

· Pliant

· Parallel Languages

· Pop

· PostScript

· Prolog

· Python

Main Sections @ eIT.in

Software

· Free & Open Source Software

· Operating Systems

o Mainframe & Legacy Operating Systems

· Midrange

· Mainframe Operating Systems

· Databases

· Programming & Development Directory

o Programming Languages

§ The A-Z of Programming Languages

§ A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z

· Internet & Web

§ Web Servers

§ Application Servers

§ Server Side Scripting

§ Web Services

Computer Hardware
Networking & Communications Technologies
IT Strategy & Design
IT in Industries & Businesses
IT in Functions & Business Processes

IT Infrastructure
Tech Support
IT, Software Industry, Trade & Business Network
IT, Software Industry News & Updates

About eIT.in

eIT.in is a comprehensive directory for everything IT & Software. It contains over 500 categories, and well over 10,000 web resources

eIT.in provides directory and web links resources for the IT, software, programming & software development domains. It is intended to be useful for application, applications programmers & developers, software technology programmer & developer, databases software development, administrators & DBAs, application developers, strategy architect, design specialists and architects, migration, integration, customization consultants and customisation analysts, administration, maintenance & support professionals, outsourcing consultant, bespoke solutions programming developers & coders, project management & functional analyst, and for system administrators, testing & quality control engineers. It will make an effort to provide resources on tutorial/tutorials, guide, guides, tips, faq, faqs on these topics.

eIT.in content is available under GPL: All directory content at mainframe.in is under the General Public License (GPL). Under this license, anyone is free to copy & use any amount of directory content @ eIT.in, make changes to it and use it in any way they wish, as long as they also allow the same rights to anyone else for this content. The concept of GPL has been adapted from the GNU GPL of the Free Software Movement. To those who wish to use content from eIT.in, our only request is that they acknowledge the source and provide a link back to eIT.in. This is only a request!

Countries & Cities Where eIT.in Provides Assistance

eIT Cities: Bangalore, Chennai, Mumbai, Bhubaneswar, Mysore, Kolkaka, Delhi, Pune, Trivandrum, Hyderabad

You are the $$$ Section of eIT.in

Reference

GeoDig – Get Local!

Have you checked out the GeoDig directories for over 30 countries? GeoDig provides useful local and regional web resources for over 200 cities around the world. See the list of cities and countries for which GeoDig provides locality-specific web resources.

North America

USA - Alabama (AL) > Birmingham; Alaska; Arkansas (AR) > Little Rock; Arizona (AZ) > Phoenix, Las Vegas, Tucson; California (CA) > Los Angeles, San Francisco, Sacramento, Fresno, Bakersfield; Colorado, CO > Denver; Connecticut, CT > Hartford; District of Columbia, DC > Washington DC; Delaware (DE) > Wilmington; Florida > Miami, Orlando, Tampa, Orlando, Sarasota, West Palm Beach, Jacksonville; Georgia > Atlanta; Hawaii > Honolulu; Idaho; Illinois > Chicago; Indiana > Indianapolis; Iowa; Kansas (KS); Kentucky (KY) > Louisville; Louisiana (LA) > New Orleans, Baton Rouge; Maine; Maryland (MD) > Baltimore; Massachusetts > Boston, Springfield; Michigan > Detroit, Grand Rapids; Minnesota > Minneapolis-St. Paul; Mississippi (MS); Missouri (MO) > Kansas City, St. Louis; Montana; Nebraska (NE) > Omaha; Nevada (NV) > Las Vegas; New Hampshire; New Jersey (NJ) > Jersey City, Newark; New Mexico (NM) > Albuquerque; New York > New York, Buffalo, Rochester, Albany, Syracuse; North Carolina (NC) > Raleigh-Durham, Charlotte, Greensboro; North Dakota; Ohio> Columbus, Cincinnati, Cleveland, Toledo, Youngstown, Dayton; Oklahoma (OK) > Oklahoma City, Tulsa; Oregon > Portland; Pennsylvania > Philadelphia, Allentown, Pittsburgh, Harrisburg, Scranton, ; Rhode Island (RI) > Providence; South Carolina (SC) > Greenville; South Dakota; Tennessee (TN) > Knoxville, Memphis, Nashville; Texas > Austin, Dallas, Houston, San Antonio, El Paso, Austin, McAllen; Utah (UT) > Salt Lake City; Vermont; Virginia (VA) > Norfolk, Richmond; Washington > Seattle; West Virginia; Wisconsin (WI) > Milwaukee; Wyoming

Canada - Vancouver, Montreal, Toronto, Calgary, Ottawa-Gatineau, Edmonton, Quebec City, Winnipeg, Hamilton, London

You are the $$$ Section of eIT.in

Europe - UK - London, Glasgow, Manchester, Birmingham, Liverpool, Sheffield, Leeds, Bristol, Edinburgh, Leicester; France - Paris, Marseille, Lyon, Toulouse, Nice, Nantes, Strasbourg, Montpellier, Bordeaux; Germany - Frankfurt (Frankfurt am Main), Munich (München), Berlin, Düsseldorf, Hamburg, Cologne (Köln), Essen, Dortmund, Stuttgart, Bremen, Duisburg, Hannover, Nürnberg (Nuremberg), Dresden, Leipzig; Italy - Milan (Milano), Rome (Roma), Napoli (Naples), Torino (Turin), Palermo, Bologna, Firenze (Florence), Genova (Genoa); Spain - Madrid, Barcelona, Valencia, Sevilla, Zaragoza, Malaga, Murcia, Las Palmas, Bilbao; Scandinavia - Finland - Helsinki (Helsingin), Espoo, Tampere (Tampereen), Vantaa, Turku, Oulu, Sweden - Stockholm, Goteborg (Göteborg), Malmo (Malmö), Uppsala, Vasteras (Västerås), Denmark - Copenhagen (Københavns), Aarhus (Århus), Odense, Aalborg (Ålborg), Norway - Oslo, Bergen, Stavanger, Trondheim; Benelux - Belgium - Brussels (Brussel), Antwerp (Antwerpen), Ghent (Gent, Gand), Charleroi, Liège (Liege), Netherlands - Amsterdam, Rotterdam, Utrecht, Eindhoven, Tilburg, ‘s-Gravenhage (sGravenhage), Groningen, Luxembourg - Luxembourg City; Portugal – Lisbon; Greece – Athens; Hungary – Budapest; Poland – Warsaw; Switzerland - Zürich (Zurich), Geneva (Geneve, Genève), Basel, Bern (Berne), Lausanne; Austria - Linz, Vienna (Wien), Graz, Linz, Salzburg, Innsbruck; Ireland – Dublin

Asia - India - Mumbai, New Delhi, Bangalore; China & Hong Kong - Hong Kong, Beijing, Shanghai, Tianjin, Wuhan, Shenyang, Guangzhou, Harbin, Xian; Japan - Tokyo, Osaka, Yokohama, Nagoya, Sapporo, Kyoto, Kobe, Fukuoka, Kawasaki, Hiroshima; South Korea - Seoul, Pusa, Taegu, Incheon, Taejeon, Taiwan - Taipei; Malaysia - Kuala Lumpur; Singapore; Russia - Moscow, St Petersburg

You are the $$$ Section of eIT.in

Middle East - Turkey - Istanbul, Israel - Tel Aviv

Oceania - Australia - Sydney, Melbourne, Brisbane, Perth, Adelaide

Africa - South Africa - Johannesburg, Cape Town, Durban

eIT.in is a product of eSource India & Sourcing India

Other eSource & Sourcing sites: IT & Software (Dir, SAP), BPO, Chemicals, Textiles, Plant Oils, dotMobi, Billion Dollar Questions,

Biodiesel Encyclopedia, Linens, ideOS, Follars – Free, Open-source Dollars, Quali5.com – Own A Keyword Forever, AntiSE, Serkai, Leather & Hide, GeoDig