In computer Science, a graph is an abstract data type, which is used to implement graph concepts from mathematics. Basically, a
graph data structure contains a set of nodes and some of them are joined by edges to form ordered pairs. The nodes could be
represented by integer indices or references, and the edges could be assigned with some edge values. [1]

This data structure is widely applied in many different fields, for instance, one programmer could use the graph data structure to
simulate computer network. However, implementing this graph from scratch in Java could be tedious. First, the programmer has to
create three different classes called node, edge and graph. Then, the graph could be implemented as either a 2-D matrix called
adjacency matrix or a list of lists call adjacency list, which are indeed two different ways used to record the relations within
the graph. And the programmer would have to keep track of the graph as well as the records.

Thus, we propose our Relational Graphing Language, in which the node, edge and graph are built-in data types in order to help
programmer to construct a graph in a much simpler way. Also, we would introduce built-in functions in the language in order to
analyze the graph, for example, we could import Facebook friend network and compute the communities within the network, or
calculating the shortest distance from node A to node B within the New York subway network.


[1] Graph (abstract data type): http://en.wikipedia.org/wiki/Graph_(abstract_data_type)

Edited Version:

Grapalate

In today’s world there is an escalating interest in relationships. Be it the connection of people on a social networking
platform, of family members in a family tree, of variables in a mathematical equation, or the connection of trains in a city
subway system, we are consistently trying to find networks of people and things and analyze how they interrelate. Most
often, relationships are implemented in a programming setting via the graph data structure containing a set of nodes and
edges defining connections between the nodes. In standard programming languages, however, graphs can be tedious to create
and manipulate, requiring the creation of separate classes for nodes and edges, and burdening the programmer to keep track
of their graphs manually. Finding and analyzing relationships between nodes of a network can be challenging. We therefore
created [insert name here], a language that provides high level abstraction to create, maintain, and manipulate graphs,
with a specific focus on the relationship between the nodes.

Our Relational Graphing Language, has the node, edge and graph as built-in data types to assist a programmer in the
simplistic construction and maintenance of graphs. When one node is connected to another, the relationship between them
is named and specific to those nodes. The graphs can be bidirectional in that there can be two different relationships
between two nodes depending on the direction of the relationship. For example, node A has the relationship of Parent to
node B, while node B has the relationship of Child with node A. The storage and maintenance of the connections and node
data occurs under the hood, without the programmer’s need to create a data structure with which to implement the graph.
This alleviates the difficulties of developing networks of nodes and eases the creation of algorithms to manipulate them.
